diff --git a/app/web/src/api/sdf/dal/action.ts b/app/web/src/api/sdf/dal/action.ts
new file mode 100644
index 0000000000..f7ab1a69a0
--- /dev/null
+++ b/app/web/src/api/sdf/dal/action.ts
@@ -0,0 +1,30 @@
+export type ActionPrototypeId = string;
+export type ActionId = string;
+
+export enum ActionState {
+  Dispatched = "Dispatched",
+  Failed = "Failed",
+  OnHold = "OnHold",
+  Queued = "Queued",
+  Running = "Running",
+}
+
+export enum ActionKind {
+  Create = "Create",
+  Destroy = "Destroy",
+  Refresh = "Refresh",
+  Manual = "Manual",
+  Update = "Update",
+}
+
+export interface ActionPrototype {
+  id: ActionPrototypeId;
+  name: string;
+  displayName: string;
+}
+
+export enum ActionResultState {
+  Success = "Success",
+  Failure = "Failure",
+  Unknown = "Unknown",
+}
diff --git a/app/web/src/api/sdf/dal/func.ts b/app/web/src/api/sdf/dal/func.ts
index b6d1c9fe6e..c2c84add20 100644
--- a/app/web/src/api/sdf/dal/func.ts
+++ b/app/web/src/api/sdf/dal/func.ts
@@ -1,5 +1,12 @@
+import { ActionKind, ActionPrototypeId } from "@/api/sdf/dal/action";
+import { InputSocketId, OutputSocketId, SchemaVariantId } from "./schema";
+import { ComponentId } from "./component";
+import { PropId } from "./prop";
+
 export type FuncArgumentId = string;
 export type FuncId = string;
+export type AttributePrototypeArgumentId = string;
+export type AttributePrototypeId = string;
 
 export enum FuncKind {
   Action = "Action",
@@ -9,7 +16,7 @@ export enum FuncKind {
   Intrinsic = "Intrinsic",
   Qualification = "Qualification",
   SchemaVariantDefinition = "SchemaVariantDefinition",
-  Unknwon = "Unknown",
+  Unknown = "Unknown",
 }
 
 export enum CustomizableFuncKind {
@@ -69,14 +76,14 @@ export const isCustomizableFuncKind = (f: FuncKind) =>
   f in CUSTOMIZABLE_FUNC_TYPES;
 
 export enum FuncArgumentKind {
-  Array = "Array",
-  Boolean = "Boolean",
-  Integer = "Integer",
-  Json = "Json",
-  Object = "Object",
-  String = "String",
-  Map = "Map",
-  Any = "Any",
+  Array = "array",
+  Boolean = "boolean",
+  Integer = "integer",
+  Json = "json",
+  Object = "object",
+  String = "string",
+  Map = "map",
+  Any = "any",
 }
 
 export interface FuncArgument {
@@ -84,4 +91,102 @@ export interface FuncArgument {
   name: string;
   kind: FuncArgumentKind;
   elementKind?: FuncArgumentKind;
+  created_at: IsoDateString;
+  updated_at: IsoDateString;
+}
+
+export interface FuncSummary {
+  funcId: FuncId;
+  kind: FuncKind;
+  name: string;
+  displayName: string | null;
+  description: string | null;
+  isLocked: boolean;
+  arguments: FuncArgument[];
+  bindings: FuncBinding[];
+}
+
+export interface FuncCode {
+  funcId: FuncId;
+  code: string;
+  types: string;
+}
+
+export interface AttributeArgumentBinding {
+  funcArgumentId: FuncArgumentId;
+  attributePrototypeArgumentId: AttributePrototypeArgumentId | null;
+  propId: PropId | null;
+  inputSocketId: InputSocketId | null;
+}
+
+export enum FuncBindingKind {
+  Action = "action",
+  Attribute = "attribute",
+  Authentication = "authentication",
+  CodeGeneration = "codeGeneration",
+  Qualification = "qualification",
+}
+
+export interface Action {
+  bindingKind: FuncBindingKind.Action;
+  // uneditable
+  funcId: FuncId | null;
+  schemaVariantId: SchemaVariantId | null;
+  actionPrototypeId: ActionPrototypeId | null;
+  // editable
+  kind: ActionKind | null;
+}
+
+export interface Attribute {
+  bindingKind: FuncBindingKind.Attribute;
+  // uneditable
+  funcId: FuncId | null;
+  attributePrototypeId: AttributePrototypeId | null;
+  // needed on create
+  schemaVariantId: SchemaVariantId | null;
+  componentId: ComponentId | null;
+  // editable
+  propId: PropId | null;
+  outputSocketId: OutputSocketId | null;
+  argumentBindings: AttributeArgumentBinding[];
 }
+
+export interface Authentication {
+  bindingKind: FuncBindingKind.Authentication;
+  funcId: FuncId;
+  schemaVariantId: SchemaVariantId;
+}
+
+export interface CodeGeneration {
+  bindingKind: FuncBindingKind.CodeGeneration;
+  funcId: FuncId | null;
+  schemaVariantId: SchemaVariantId | null;
+  attributePrototypeId: AttributePrototypeId | null;
+  componentId: ComponentId | null;
+  // editable
+  inputs: LeafInputLocation[];
+}
+
+export interface Qualification {
+  bindingKind: FuncBindingKind.Qualification;
+  funcId: FuncId | null;
+  schemaVariantId: SchemaVariantId | null;
+  attributePrototypeId: AttributePrototypeId | null;
+  componentId: ComponentId | null;
+  // editable
+  inputs: LeafInputLocation[];
+}
+
+export type FuncBinding =
+  | Action
+  | Attribute
+  | Authentication
+  | CodeGeneration
+  | Qualification;
+
+export type LeafInputLocation =
+  | "code"
+  | "deletedAt"
+  | "domain"
+  | "resource"
+  | "secrets";
diff --git a/app/web/src/api/sdf/dal/prop.ts b/app/web/src/api/sdf/dal/prop.ts
index eda846538f..d88707b97d 100644
--- a/app/web/src/api/sdf/dal/prop.ts
+++ b/app/web/src/api/sdf/dal/prop.ts
@@ -9,3 +9,14 @@ export enum PropKind {
   String = "string",
   Map = "map",
 }
+
+export interface Prop {
+  id: PropId;
+  kind: PropKind;
+  name: string;
+  path: string;
+  // this is for output sources
+  eligibleToReceiveData: boolean;
+  // this is for input sources
+  eligibleToSendData: boolean;
+}
diff --git a/app/web/src/api/sdf/dal/schema.ts b/app/web/src/api/sdf/dal/schema.ts
index 0bb0763d50..c84e428920 100644
--- a/app/web/src/api/sdf/dal/schema.ts
+++ b/app/web/src/api/sdf/dal/schema.ts
@@ -1,5 +1,6 @@
 import { StandardModel } from "@/api/sdf/dal/standard_model";
 import { FuncId } from "@/api/sdf/dal/func";
+import { Prop, PropId } from "@/api/sdf/dal/prop";
 
 export enum SchemaKind {
   Concept = "concept",
@@ -30,6 +31,7 @@ export type OutputSocketId = string;
 export interface OutputSocket {
   id: OutputSocketId;
   name: string;
+  eligibleToReceiveData: boolean;
 }
 
 export type InputSocketId = string;
@@ -37,6 +39,7 @@ export type InputSocketId = string;
 export interface InputSocket {
   id: InputSocketId;
   name: string;
+  eligibleToSendData: boolean;
 }
 
 export interface SchemaVariant {
@@ -61,4 +64,55 @@ export interface SchemaVariant {
 
   inputSockets: InputSocket[];
   outputSockets: OutputSocket[];
+  props: Prop[];
 }
+
+export const outputSocketsAndPropsFor = (schemaVariant: SchemaVariant) => {
+  const socketOptions = schemaVariant.outputSockets.map((socket) => ({
+    label: `Output Socket: ${socket.name}`,
+    value: `s_${socket.id}`,
+  }));
+
+  // output
+  const propOptions = schemaVariant.props
+    .filter((p) => p.eligibleToReceiveData)
+    .map((p) => ({
+      label: `Attribute: ${p.path}`,
+      value: `p_${p.id}`,
+    }));
+  return { socketOptions, propOptions };
+};
+
+export const inputSocketsAndPropsFor = (schemaVariant: SchemaVariant) => {
+  const socketOptions = schemaVariant.inputSockets.map((socket) => ({
+    label: `Input Socket: ${socket.name}`,
+    value: `s_${socket.id}`,
+  }));
+
+  const propOptions = schemaVariant.props
+    .filter((p) => p.eligibleToSendData)
+    .map((p) => ({
+      label: `Attribute: ${p.path}`,
+      value: `p_${p.id}`,
+    }));
+
+  return { socketOptions, propOptions };
+};
+
+export const findSchemaVariantForPropOrSocketId = (
+  schemaVariants: SchemaVariant[],
+  propId: PropId | null | undefined,
+  outputSocketId: OutputSocketId | null | undefined,
+) => {
+  if (propId && outputSocketId) throw new Error("Either prop or output socket");
+
+  return schemaVariants.find((sv) => {
+    if (propId && sv.props.map((p) => p.id).includes(propId)) return sv;
+    if (
+      outputSocketId &&
+      sv.outputSockets.map((o) => o.id).includes(outputSocketId)
+    )
+      return sv;
+    return undefined;
+  });
+};
diff --git a/app/web/src/components/Actions/ActionCard.vue b/app/web/src/components/Actions/ActionCard.vue
index 9ea8652b95..1f7aef836a 100644
--- a/app/web/src/components/Actions/ActionCard.vue
+++ b/app/web/src/components/Actions/ActionCard.vue
@@ -246,12 +246,10 @@ import {
 } from "@si/vue-lib/design-system";
 import clsx from "clsx";
 import { FullComponent, useComponentsStore } from "@/store/components.store";
+import { ActionKind, ActionState, ActionId } from "@/api/sdf/dal/action";
 import {
-  ActionKind,
-  ActionState,
   ActionView,
   useActionsStore,
-  ActionId,
   ActionProposedView,
   ActionHistoryView,
 } from "@/store/actions.store";
diff --git a/app/web/src/components/Actions/ActionWidget.vue b/app/web/src/components/Actions/ActionWidget.vue
index 854f6fb7f6..f21898ea48 100644
--- a/app/web/src/components/Actions/ActionWidget.vue
+++ b/app/web/src/components/Actions/ActionWidget.vue
@@ -28,7 +28,8 @@ import * as _ from "lodash-es";
 import clsx from "clsx";
 import { PropType, computed } from "vue";
 import { Icon, themeClasses } from "@si/vue-lib/design-system";
-import { ActionPrototypeId, useActionsStore } from "@/store/actions.store";
+import { useActionsStore } from "@/store/actions.store";
+import { ActionPrototypeId } from "@/api/sdf/dal/action";
 import { ComponentId } from "@/api/sdf/dal/component";
 import StatusIndicatorIcon from "../StatusIndicatorIcon.vue";
 import Toggle from "./Toggle.vue";
diff --git a/app/web/src/components/AssetCard.vue b/app/web/src/components/AssetCard.vue
index e1d6aa4a79..753c39b698 100644
--- a/app/web/src/components/AssetCard.vue
+++ b/app/web/src/components/AssetCard.vue
@@ -149,7 +149,7 @@ const unlock = async () => {
       asset.value.schemaVariantId,
     );
     if (resp.result.success) {
-      assetStore.setSchemaVariantSelection(resp.result.data?.id);
+      assetStore.setSchemaVariantSelection(resp.result.data?.id, true);
     }
   }
 };
diff --git a/app/web/src/components/AssetDetailsPanel.vue b/app/web/src/components/AssetDetailsPanel.vue
index 3fb2245141..7d1598d6c5 100644
--- a/app/web/src/components/AssetDetailsPanel.vue
+++ b/app/web/src/components/AssetDetailsPanel.vue
@@ -181,7 +181,6 @@ import * as _ from "lodash-es";
 import { FuncKind, FuncId } from "@/api/sdf/dal/func";
 import { useAssetStore } from "@/store/asset.store";
 import { useFeatureFlagsStore } from "@/store/feature_flags.store";
-import { useFuncStore } from "@/store/func/funcs.store";
 import { ComponentType } from "@/api/sdf/dal/schema";
 import ColorPicker from "./ColorPicker.vue";
 import AssetFuncAttachModal from "./AssetFuncAttachModal.vue";
@@ -193,7 +192,6 @@ const props = defineProps<{
 
 const ffStore = useFeatureFlagsStore();
 const assetStore = useAssetStore();
-const funcStore = useFuncStore();
 const loadAssetReqStatus = assetStore.getRequestStatus(
   "LOAD_SCHEMA_VARIANT",
   props.assetId,
@@ -238,13 +236,13 @@ const updateAsset = async () => {
     editingAsset.value &&
     !_.isEqual(editingAsset.value, assetStore.selectedSchemaVariant)
   ) {
-    const code =
-      funcStore.funcDetailsById[editingAsset.value.assetFuncId]?.code;
-    if (code) await assetStore.SAVE_SCHEMA_VARIANT(editingAsset.value);
-    else
+    // const code = funcStore.funcCodeById[editingAsset.value.assetFuncId]?.code;
+    // if (code)
+    await assetStore.SAVE_SCHEMA_VARIANT(editingAsset.value);
+    /* else
       throw new Error(
         `${editingAsset.value.assetFuncId} Func not found on Variant ${editingAsset.value.schemaVariantId}. This should not happen.`,
-      );
+      ); */
   }
 };
 
@@ -274,7 +272,7 @@ const cloneAsset = async (name: string) => {
     );
     if (result.result.success) {
       cloneAssetModalRef.value?.modal?.close();
-      await assetStore.setSchemaVariantSelection(result.result.data.id);
+      await assetStore.setSchemaVariantSelection(result.result.data.id, true);
     }
   }
 };
diff --git a/app/web/src/components/AssetEditor.vue b/app/web/src/components/AssetEditor.vue
index 0ee8df4c59..41df4fc3fa 100644
--- a/app/web/src/components/AssetEditor.vue
+++ b/app/web/src/components/AssetEditor.vue
@@ -93,7 +93,7 @@ const selectedAsset = computed(() =>
 const selectedAssetFuncCode = computed(() => {
   const fId = selectedAsset.value?.assetFuncId;
   if (!fId) return null;
-  return funcStore.funcDetailsById[fId]?.code;
+  return funcStore.funcCodeById[fId]?.code;
 });
 
 const isReadOnly = computed(() => {
diff --git a/app/web/src/components/AssetFuncAttachModal.vue b/app/web/src/components/AssetFuncAttachModal.vue
index 372c706446..e336c68f23 100644
--- a/app/web/src/components/AssetFuncAttachModal.vue
+++ b/app/web/src/components/AssetFuncAttachModal.vue
@@ -35,7 +35,7 @@
           required
           :options="existingFuncOptions"
         />
-        <template v-if="funcKind === FuncKind.Action && !attachExisting">
+        <template v-if="funcKind === FuncKind.Action">
           <div class="text-neutral-700 type-bold-sm dark:text-neutral-50">
             <SiCheckBox
               id="create"
@@ -141,7 +141,7 @@ import {
 } from "@si/vue-lib/design-system";
 import clsx from "clsx";
 import * as _ from "lodash-es";
-import { ActionKind } from "@/store/actions.store";
+import { ActionKind } from "@/api/sdf/dal/action";
 import SiCheckBox from "@/components/SiCheckBox.vue";
 import {
   CUSTOMIZABLE_FUNC_TYPES,
@@ -149,15 +149,22 @@ import {
   FuncKind,
   FuncId,
   FuncArgumentId,
+  FuncBindingKind,
+  FuncBinding,
+  Authentication,
+  CodeGeneration,
+  Action,
+  Attribute,
+  Qualification,
+  AttributeArgumentBinding,
 } from "@/api/sdf/dal/func";
+import {
+  outputSocketsAndPropsFor,
+  inputSocketsAndPropsFor,
+} from "@/api/sdf/dal/schema";
 import SelectMenu, { Option } from "@/components/SelectMenu.vue";
 import { useFuncStore } from "@/store/func/funcs.store";
 import { useAssetStore } from "@/store/asset.store";
-import {
-  CreateFuncOptions,
-  CreateFuncOutputLocation,
-  FuncAssociations,
-} from "@/store/func/types";
 import { nilId } from "@/utils/nilId";
 import CodeEditor from "./CodeEditor.vue";
 
@@ -198,10 +205,16 @@ const name = ref("");
 const funcKind = ref(FuncKind.Action);
 
 const selectedExistingFuncId = ref<FuncId | undefined>();
+const selectedExistingFuncSummary = computed(() => {
+  if (selectedExistingFuncId.value)
+    return funcStore.funcsById[selectedExistingFuncId.value];
+
+  return undefined;
+});
 const selectedFuncCode = ref<string>("");
 const loadFuncDetailsReq = computed(() =>
   selectedExistingFuncId.value
-    ? funcStore.getRequestStatus("FETCH_FUNC", selectedExistingFuncId.value)
+    ? funcStore.getRequestStatus("FETCH_CODE", selectedExistingFuncId.value)
     : undefined,
 );
 
@@ -209,19 +222,13 @@ watch(
   selectedExistingFuncId,
   async (funcId) => {
     if (funcId) {
-      if (
-        !funcStore.funcDetailsById[funcId] ||
-        !funcStore.funcArgumentsByFuncId[funcId]
-      ) {
-        await funcStore.FETCH_FUNC_ARGUMENT_LIST(funcId);
-      } else {
-        selectedFuncCode.value = funcStore.funcDetailsById[funcId]?.code ?? "";
-      }
+      await funcStore.FETCH_CODE(funcId);
+      selectedFuncCode.value = funcStore.funcCodeById[funcId]?.code || "";
 
       editableBindings.value = [];
-      if (func.value?.associations?.type === "attribute") {
+      if (selectedExistingFuncSummary.value?.kind === FuncKind.Attribute) {
         editableBindings.value =
-          funcStore.funcArgumentsByFuncId[func.value.id]?.map((a) => ({
+          selectedExistingFuncSummary.value.arguments?.map((a) => ({
             funcArgumentId: a.id,
             binding: noneSource,
           })) ?? [];
@@ -236,45 +243,20 @@ const existingFuncOptions = computed(() =>
     .filter((func) => func.kind === funcKind.value)
     .map((func) => ({
       label: func.name,
-      value: func.id,
+      value: func.funcId,
     })),
 );
 
-// VormInput does not support object types for option values, so we do transform
-// the value into JSON and parse it back to use it
 const attributeOutputLocation = ref<string | undefined>();
-const attributeOutputLocationParsed = computed<
-  CreateFuncOutputLocation | undefined
->(() => {
-  const parsed = attributeOutputLocation.value
-    ? JSON.parse(attributeOutputLocation.value)
-    : undefined;
-
-  if (parsed) {
-    if ("propId" in parsed && parsed.propId) {
-      return {
-        type: "prop",
-        propId: parsed.propId,
-      };
-    } else if ("outputSocketId" in parsed && parsed.outputSocketId) {
-      return {
-        type: "outputSocket",
-        outputSocketId: parsed.outputSocketId,
-      };
-    }
-  }
-
-  return undefined;
-});
-const attributeOutputLocationOptions = ref<{ label: string; value: string }[]>(
-  [],
-);
+const attributeOutputLocationOptions = ref<Option[]>([]);
 
 const attrToValidate = ref<string | undefined>();
-const validationOptions = ref<{ label: string; value: string }[]>([]);
 
 const assetName = computed(
-  () => assetStore.selectedSchemaVariant?.schemaName ?? " none",
+  () =>
+    assetStore.selectedSchemaVariant?.displayName ??
+    assetStore.selectedSchemaVariant?.schemaName ??
+    " none",
 );
 
 const existingOrNew = computed(() =>
@@ -294,14 +276,14 @@ const attachEnabled = computed(() => {
   const nameIsSet =
     attachExisting.value || !!(name.value && name.value.length > 0);
   const hasOutput =
-    funcKind.value !== FuncKind.Attribute ||
-    !!attributeOutputLocationParsed.value;
+    funcKind.value !== FuncKind.Attribute || !!attributeOutputLocation.value;
   const existingSelected =
     !attachExisting.value || !!selectedExistingFuncId.value;
   const argsConfigured =
     !attachExisting.value ||
     funcKind.value !== FuncKind.Attribute ||
     editableBindings.value.every((b) => b.binding.value !== nilId());
+
   return nameIsSet && hasOutput && existingSelected && argsConfigured;
 });
 
@@ -323,109 +305,26 @@ const open = async (
   selectedExistingFuncId.value = funcId;
   attrToValidate.value = undefined;
 
-  await funcStore.FETCH_INPUT_SOURCE_LIST(schemaVariantId.value);
-  attributeOutputLocationOptions.value = schemaVariantId.value
-    ? funcStore
-        .outputLocationOptionsForSchemaVariant(schemaVariantId.value)
-        .map(({ label, value }) => ({
-          label,
-          value: JSON.stringify(value),
-        }))
-    : [];
-
-  validationOptions.value = schemaVariantId.value
-    ? funcStore.propsAsOptionsForSchemaVariant(schemaVariantId.value)
-    : [];
-
-  openModal();
-};
-
-const newFuncOptions = (
-  funcKind: FuncKind,
-  schemaVariantId: string,
-): CreateFuncOptions => {
-  const baseOptions = {
-    schemaVariantId,
-  };
+  attributeOutputLocationOptions.value = [];
+  if (props.assetId) {
+    const schemaVariant = assetStore.variantsById[props.assetId];
+    if (schemaVariant) {
+      const { socketOptions, propOptions } =
+        outputSocketsAndPropsFor(schemaVariant);
 
-  let kind = ActionKind.Manual;
-  switch (funcKind) {
-    case FuncKind.Authentication:
-      return {
-        type: "authenticationOptions",
-        ...baseOptions,
-      };
-    case FuncKind.Action:
-      if (isCreate.value) kind = ActionKind.Create;
-      if (isDelete.value) kind = ActionKind.Destroy;
-      if (isRefresh.value) kind = ActionKind.Refresh;
-
-      return {
-        type: "actionOptions",
-        actionKind: kind,
-        ...baseOptions,
-      };
-    case FuncKind.Attribute:
-      if (attributeOutputLocationParsed.value) {
-        return {
-          type: "attributeOptions",
-          outputLocation: attributeOutputLocationParsed.value,
-        };
-      }
-      throw new Error(
-        `attributeOutputLocationParsed not defined for Attribute`,
-      );
-
-    case FuncKind.CodeGeneration:
-      return {
-        type: "codeGenerationOptions",
-        ...baseOptions,
-      };
-    case FuncKind.Qualification:
-      return {
-        type: "qualificationOptions",
-        ...baseOptions,
-      };
-    default:
-      throw new Error(`newFuncOptions not defined for ${funcKind}`);
+      attributeOutputLocationOptions.value = [...socketOptions, ...propOptions];
+    }
   }
-};
 
-const attachToAttributeFunction = async (
-  outputLocation: CreateFuncOutputLocation,
-) => {
-  if (!selectedExistingFuncId.value || !schemaVariantId.value) return;
-  const prototypes = editableBindings.value.map((b) => ({
-    id: nilId(),
-    funcArgumentId: b.funcArgumentId,
-    inputSocketId: b.binding.label.includes("Input Socket")
-      ? (b.binding.value as string)
-      : undefined,
-    propId: b.binding.label.includes("Attribute")
-      ? (b.binding.value as string)
-      : undefined,
-  }));
-  await funcStore.CREATE_ATTRIBUTE_PROTOTYPE(
-    selectedExistingFuncId.value,
-    schemaVariantId.value,
-    prototypes,
-    nilId(),
-    "propId" in outputLocation ? outputLocation.propId : undefined,
-    "outputSocketId" in outputLocation
-      ? outputLocation.outputSocketId
-      : undefined,
-  );
+  openModal();
 };
 
+// NOT SURE I NEED THIS
 const reloadAssetAndRoute = async (assetId: string) => {
   await assetStore.LOAD_SCHEMA_VARIANT(assetId);
   close();
 };
 
-const func = computed(
-  () => funcStore.funcDetailsById[selectedExistingFuncId.value ?? -1],
-);
-
 interface EditingBinding {
   funcArgumentId: string;
   binding: Option;
@@ -433,82 +332,140 @@ interface EditingBinding {
 
 const editableBindings = ref<EditingBinding[]>([]);
 const inputSourceOptions = computed<Option[]>(() => {
-  const selectedVariantId = schemaVariantId.value ?? -1;
-  const socketOptions =
-    funcStore.inputSourceSockets[selectedVariantId]?.map((socket) => ({
-      label: `Input Socket: ${socket.name}`,
-      value: socket.inputSocketId,
-    })) ?? [];
-
-  const propOptions =
-    funcStore.inputSourceProps[selectedVariantId]?.map((prop) => ({
-      label: `Attribute: ${prop.path}`,
-      value: prop.propId,
-    })) ?? [];
+  let socketOptions: Option[] = [];
+  let propOptions: Option[] = [];
+  if (schemaVariantId.value) {
+    const variant = assetStore.variantsById[schemaVariantId.value];
+    if (variant) {
+      ({ socketOptions, propOptions } = inputSocketsAndPropsFor(variant));
+    }
+  }
 
   return socketOptions.concat(propOptions);
 });
 const funcArgumentName = (
   funcArgumentId: FuncArgumentId,
 ): string | undefined => {
-  return funcStore.funcArgumentsById[funcArgumentId]?.name;
+  return selectedExistingFuncSummary.value?.arguments
+    .filter((a) => a.id === funcArgumentId)
+    .pop()?.name;
 };
 const noneSource = { label: "select source", value: nilId() };
 
+const commonBindingConstruction = () => {
+  const binding = {
+    funcId: selectedExistingFuncId.value,
+    schemaVariantId: schemaVariantId.value,
+  } as unknown;
+  switch (funcKind.value) {
+    case FuncKind.Authentication:
+      // eslint-disable-next-line no-case-declarations
+      const auth = binding as Authentication;
+      auth.bindingKind = FuncBindingKind.Authentication;
+      return auth;
+    case FuncKind.Action:
+      // eslint-disable-next-line no-case-declarations
+      const action = binding as Action;
+      action.bindingKind = FuncBindingKind.Action;
+      if (isCreate.value) action.kind = ActionKind.Create;
+      if (isDelete.value) action.kind = ActionKind.Destroy;
+      if (isRefresh.value) action.kind = ActionKind.Refresh;
+      if (!isRefresh.value && !isDelete.value && !isCreate.value)
+        action.kind = ActionKind.Manual;
+      return action;
+    case FuncKind.CodeGeneration:
+      // eslint-disable-next-line no-case-declarations
+      const bind = binding as CodeGeneration;
+      bind.inputs = [];
+      bind.bindingKind = FuncBindingKind.CodeGeneration;
+      return bind;
+    case FuncKind.Qualification:
+      // eslint-disable-next-line no-case-declarations
+      const qual = binding as Qualification;
+      qual.inputs = [];
+      qual.bindingKind = FuncBindingKind.Qualification;
+      return qual;
+    default:
+      return null;
+  }
+};
+
 const attachExistingFunc = async () => {
-  if (schemaVariantId.value && selectedExistingFuncId.value) {
-    const func = funcStore.funcDetailsById[selectedExistingFuncId.value];
-    if (func) {
-      let updatedAssociations: FuncAssociations | undefined;
-      const associations = func?.associations;
-      if (!associations) {
-        return;
-      }
+  const bindings: FuncBinding[] = [];
+
+  const binding = commonBindingConstruction();
+  if (binding) bindings.push(binding);
+
+  if (funcKind.value === FuncKind.Attribute) {
+    const attr = {
+      funcId: selectedExistingFuncId.value,
+      schemaVariantId: schemaVariantId.value,
+      bindingKind: FuncBindingKind.Attribute,
+    } as Attribute;
+    const argBindings: AttributeArgumentBinding[] = [];
+    editableBindings.value.forEach(async (b) => {
+      const arg = {
+        funcArgumentId: b.funcArgumentId,
+      } as AttributeArgumentBinding;
+      const bString = b.binding.value as string;
+      if (bString.startsWith("s_"))
+        arg.inputSocketId = bString.replace("s_", "");
+      else if (bString.startsWith("p_")) arg.propId = bString.replace("p_", "");
+
+      argBindings.push(arg);
+    });
+    attr.argumentBindings = argBindings;
+    if (attributeOutputLocation.value?.startsWith("s_"))
+      attr.outputSocketId = attributeOutputLocation.value.replace("s_", "");
+    else if (attributeOutputLocation.value?.startsWith("p_"))
+      attr.propId = attributeOutputLocation.value.replace("p_", "");
 
-      switch (associations.type) {
-        case "authentication":
-        case "action":
-        case "codeGeneration":
-        case "qualification":
-          updatedAssociations = _.cloneDeep(associations);
-          updatedAssociations.schemaVariantIds.push(schemaVariantId.value);
-          break;
-        case "attribute":
-          if (attributeOutputLocationParsed.value) {
-            attachToAttributeFunction(attributeOutputLocationParsed.value);
-            if (props.assetId) await reloadAssetAndRoute(props.assetId);
-          }
-          break;
-        default:
-          throw new Error(
-            `type "${
-              (associations as FuncAssociations)?.type
-            }" is not supported by attachExistingFunc`,
-          );
-      }
-      if (updatedAssociations) {
-        func.associations = updatedAssociations;
-        const response = await funcStore.UPDATE_FUNC(func);
-        if (response.result.success && props.assetId) {
-          await reloadAssetAndRoute(props.assetId);
-        }
-      }
+    bindings.push(attr);
+  }
+  if (bindings.length > 0 && selectedExistingFuncId.value) {
+    const response = await funcStore.CREATE_BINDING(
+      selectedExistingFuncId.value,
+      bindings,
+    );
+    if (response.result.success && props.assetId) {
+      await reloadAssetAndRoute(props.assetId);
     }
   }
 };
 
 const attachNewFunc = async () => {
   if (schemaVariantId.value) {
-    const options = newFuncOptions(funcKind.value, schemaVariantId.value);
     createFuncStarted.value = true;
+    let binding = commonBindingConstruction() as FuncBinding;
+    if (!binding) {
+      let outputSocketId;
+      let propId;
+      if (attributeOutputLocation.value?.startsWith("s_"))
+        outputSocketId = attributeOutputLocation.value.replace("s_", "");
+      else if (attributeOutputLocation.value?.startsWith("p_"))
+        propId = attributeOutputLocation.value.replace("p_", "");
+
+      binding = {
+        funcId: selectedExistingFuncId.value,
+        schemaVariantId: schemaVariantId.value,
+        bindingKind: FuncBindingKind.Attribute,
+        argumentBindings: [],
+        propId,
+        outputSocketId,
+        componentId: null,
+        attributePrototypeId: null,
+      } as Attribute;
+    }
     const result = await funcStore.CREATE_FUNC({
-      kind: funcKind.value,
       name: name.value,
-      options,
+      displayName: name.value,
+      description: "",
+      binding,
+      kind: funcKind.value,
     });
     if (result.result.success) {
-      funcStore.selectedFuncId = result.result.data.id;
-      assetStore.addFuncSelection(result.result.data.id);
+      funcStore.selectedFuncId = result.result.data.summary.funcId;
+      assetStore.addFuncSelection(result.result.data.summary.funcId);
       if (props.assetId) await reloadAssetAndRoute(props.assetId);
     }
   }
diff --git a/app/web/src/components/AssetFuncListPanel.vue b/app/web/src/components/AssetFuncListPanel.vue
index 88826f0b16..d1ce209a42 100644
--- a/app/web/src/components/AssetFuncListPanel.vue
+++ b/app/web/src/components/AssetFuncListPanel.vue
@@ -50,7 +50,8 @@ import { computed, ref } from "vue";
 import groupBy from "lodash-es/groupBy";
 import { RequestStatusMessage, ScrollArea } from "@si/vue-lib/design-system";
 import { useAssetStore, SchemaVariantListEntry } from "@/store/asset.store";
-import { FuncSummary, useFuncStore } from "@/store/func/funcs.store";
+import { useFuncStore } from "@/store/func/funcs.store";
+import { FuncSummary } from "@/api/sdf/dal/func";
 import SidebarSubpanelTitle from "@/components/SidebarSubpanelTitle.vue";
 import AssetFuncAttachModal from "./AssetFuncAttachModal.vue";
 import AssetFuncAttachDropdown from "./AssetFuncAttachDropdown.vue";
diff --git a/app/web/src/components/AssetListItem.vue b/app/web/src/components/AssetListItem.vue
index c1814f03af..c3c303b97b 100644
--- a/app/web/src/components/AssetListItem.vue
+++ b/app/web/src/components/AssetListItem.vue
@@ -64,6 +64,6 @@ const { selectedSchemaVariants: selectedAssets } = storeToRefs(assetStore);
 
 const onClick = (e: MouseEvent) => {
   if (e.shiftKey) assetStore.addSchemaVariantSelection(props.a.schemaVariantId);
-  else assetStore.setSchemaVariantSelection(props.a.schemaVariantId);
+  else assetStore.setSchemaVariantSelection(props.a.schemaVariantId, true);
 };
 </script>
diff --git a/app/web/src/components/AssetListPanel.vue b/app/web/src/components/AssetListPanel.vue
index 07d750c315..0745519cb4 100644
--- a/app/web/src/components/AssetListPanel.vue
+++ b/app/web/src/components/AssetListPanel.vue
@@ -232,7 +232,7 @@ const categoryColor = (category: string) => {
 const newAsset = async (newAssetName: string) => {
   const result = await assetStore.CREATE_VARIANT(newAssetName);
   if (result.result.success) {
-    assetStore.setSchemaVariantSelection(result.result.data.id);
+    assetStore.setSchemaVariantSelection(result.result.data.id, true);
     newAssetModalRef.value?.modal?.close();
   } else if (result.result.statusCode === 409) {
     if (newAssetModalRef.value) {
diff --git a/app/web/src/components/AssetNameModal.vue b/app/web/src/components/AssetNameModal.vue
index 492b0ef4bc..55f7e474a0 100644
--- a/app/web/src/components/AssetNameModal.vue
+++ b/app/web/src/components/AssetNameModal.vue
@@ -28,6 +28,7 @@ const assetNameVorm = ref<InstanceType<typeof VormInput>>();
 
 const submit = () => {
   emit("submit", assetName.value);
+  assetName.value = "";
 };
 
 const setError = (msg: string) => {
diff --git a/app/web/src/components/ChangesPanelProposed.vue b/app/web/src/components/ChangesPanelProposed.vue
index 59e2bc80a5..471109e658 100644
--- a/app/web/src/components/ChangesPanelProposed.vue
+++ b/app/web/src/components/ChangesPanelProposed.vue
@@ -51,12 +51,11 @@
 import * as _ from "lodash-es";
 import { ref, reactive, computed } from "vue";
 import { VButton } from "@si/vue-lib/design-system";
+import { ActionId, ActionState } from "@/api/sdf/dal/action";
 import {
   useActionsStore,
   ActionProposedView,
-  ActionId,
   ActionView,
-  ActionState,
 } from "@/store/actions.store";
 import FuncRunTabGroup from "@/components/Actions/FuncRunTabGroup.vue";
 import { FuncRun, useFuncRunsStore } from "@/store/func_runs.store";
diff --git a/app/web/src/components/FuncEditor/ActionDetails.vue b/app/web/src/components/FuncEditor/ActionDetails.vue
index a9b7659a9b..78256d8fad 100644
--- a/app/web/src/components/FuncEditor/ActionDetails.vue
+++ b/app/web/src/components/FuncEditor/ActionDetails.vue
@@ -1,6 +1,5 @@
 <template>
   <div class="p-xs flex flex-col gap-xs">
-    <ErrorMessage :requestStatus="props.requestStatus" />
     <div class="text-neutral-700 type-bold-sm dark:text-neutral-50">
       <SiCheckBox
         id="create"
@@ -28,53 +27,55 @@
         @update:model-value="setDelete"
       />
     </div>
-    <template v-if="!schemaVariantId">
-      <div class="text-neutral-700 type-bold-sm dark:text-neutral-50">
-        Run on Assets of Type:
-      </div>
-      <RunOnSelector
-        v-model="selectedVariants"
-        thingLabel="assets of type"
-        :options="schemaVariantOptions"
-        :disabled="disabled"
-        @change="updateAssociations"
-      />
-    </template>
   </div>
 </template>
 
 <script lang="ts" setup>
-import { ref, toRef, watch } from "vue";
+import { ref, watch, computed } from "vue";
 import { storeToRefs } from "pinia";
-import { ApiRequestStatus } from "@si/vue-lib/pinia";
-import { ErrorMessage } from "@si/vue-lib/design-system";
 import { Option } from "@/components/SelectMenu.vue";
-import { ActionAssociations, FuncAssociations } from "@/store/func/types";
 import SiCheckBox from "@/components/SiCheckBox.vue";
 import { toOptionValues } from "@/components/FuncEditor/utils";
 import { useFuncStore } from "@/store/func/funcs.store";
-import { ActionKind } from "@/store/actions.store";
-import RunOnSelector from "./RunOnSelector.vue";
+import { useComponentsStore } from "@/store/components.store";
+import { ActionKind } from "@/api/sdf/dal/action";
+import { FuncId } from "@/api/sdf/dal/func";
+import { SchemaVariantId } from "@/api/sdf/dal/schema";
+import { nonNullable } from "@/utils/typescriptLinter";
 
 const funcStore = useFuncStore();
-const { componentOptions, schemaVariantOptions } = storeToRefs(funcStore);
+const componentsStore = useComponentsStore();
+const { schemaVariantOptions } = storeToRefs(componentsStore);
 
 const props = defineProps<{
-  modelValue: ActionAssociations;
-  schemaVariantId?: string;
+  funcId: FuncId;
+  schemaVariantId: SchemaVariantId;
   disabled?: boolean;
-  requestStatus: ApiRequestStatus;
 }>();
 
 const isCreate = ref(false);
 const isDelete = ref(false);
 const isRefresh = ref(false);
+
+const binding = computed(() => {
+  const bindings = funcStore.actionBindings[props.funcId];
+  const binding = bindings
+    ?.filter((b) => b.schemaVariantId === props.schemaVariantId)
+    .pop();
+  return binding;
+});
+
+const validSchemaVariantIds = computed(() => {
+  const bindings = funcStore.actionBindings[props.funcId];
+  return bindings?.map((b) => b.schemaVariantId).filter(nonNullable);
+});
+
 watch(
-  () => props.modelValue.kind,
+  binding,
   () => {
-    isCreate.value = props.modelValue.kind === ActionKind.Create;
-    isDelete.value = props.modelValue.kind === ActionKind.Destroy;
-    isRefresh.value = props.modelValue.kind === ActionKind.Refresh;
+    isCreate.value = binding.value?.kind === ActionKind.Create;
+    isDelete.value = binding.value?.kind === ActionKind.Destroy;
+    isRefresh.value = binding.value?.kind === ActionKind.Refresh;
   },
   { immediate: true },
 );
@@ -100,62 +101,33 @@ const setDelete = () => {
   updateKind();
 };
 
-const modelValue = toRef(props, "modelValue");
-
 const selectedVariants = ref<Option[]>(
-  toOptionValues(schemaVariantOptions.value, modelValue.value.schemaVariantIds),
+  toOptionValues(schemaVariantOptions.value, validSchemaVariantIds.value || []),
 );
 
-const emit = defineEmits<{
-  (e: "update:modelValue", v: ActionAssociations): void;
-  (e: "change", v: ActionAssociations): void;
-  (e: "detach", v: ActionAssociations): void;
-}>();
-
 watch(
-  [modelValue, schemaVariantOptions, componentOptions],
-  ([mv, svOpts]) => {
-    selectedVariants.value = toOptionValues(svOpts, mv.schemaVariantIds);
+  [validSchemaVariantIds, schemaVariantOptions],
+  () => {
+    selectedVariants.value = toOptionValues(
+      schemaVariantOptions.value,
+      validSchemaVariantIds.value || [],
+    );
   },
   { immediate: true },
 );
 
 const updateKind = () => {
-  if (selectedVariants.value.length > 0) {
-    updateAssociations();
+  if (binding.value) {
+    binding.value.kind = ActionKind.Manual;
+    if (isCreate.value) binding.value.kind = ActionKind.Create;
+    if (isDelete.value) binding.value.kind = ActionKind.Destroy;
+    if (isRefresh.value) binding.value.kind = ActionKind.Refresh;
+    funcStore.UPDATE_BINDING(props.funcId, [binding.value]);
   }
 };
 
-const getUpdatedAssociations = (
-  schemaVariantIds: string[],
-): ActionAssociations => {
-  let kind = ActionKind.Manual;
-  if (isCreate.value) kind = ActionKind.Create;
-  if (isDelete.value) kind = ActionKind.Destroy;
-  if (isRefresh.value) kind = ActionKind.Refresh;
-  return {
-    kind,
-    schemaVariantIds,
-    type: "action",
-  };
-};
-
-const updateAssociations = () => {
-  const associations = getUpdatedAssociations(
-    selectedVariants.value.map(({ value }) => value as string),
-  );
-  emit("update:modelValue", associations);
-  emit("change", associations);
-};
-
-const detachFunc = (): FuncAssociations | undefined => {
-  if (props.schemaVariantId) {
-    return getUpdatedAssociations(
-      selectedVariants.value
-        .map(({ value }) => value as string)
-        .filter((schemaVariantId) => schemaVariantId !== props.schemaVariantId),
-    );
-  }
+const detachFunc = () => {
+  if (binding.value) funcStore.DELETE_BINDING(props.funcId, [binding.value]);
 };
 
 defineExpose({ detachFunc });
diff --git a/app/web/src/components/FuncEditor/AttributeBindings.vue b/app/web/src/components/FuncEditor/AttributeBindings.vue
index 6e561bd42e..e850f600aa 100644
--- a/app/web/src/components/FuncEditor/AttributeBindings.vue
+++ b/app/web/src/components/FuncEditor/AttributeBindings.vue
@@ -13,28 +13,39 @@
         @click="openModal()"
       />
     </div>
-    <template v-if="prototypeViews.length > 0">
+    <template v-if="bindings && bindings.length > 0">
       <ul class="flex flex-col p-3 gap-2xs break-words">
-        <li v-for="proto in prototypeViews" :key="proto.id">
+        <li v-for="bind in bindings" :key="bind.attributePrototypeId">
           <h1 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50">
             Asset:
           </h1>
-          <h2 class="pb-xs text-sm">{{ proto.schema }}</h2>
+          <h2 class="pb-xs text-sm">
+            {{
+              componentStore.schemaVariantsById[bind.schemaVariantId || ""]
+                ?.displayName || "N/A"
+            }}
+          </h2>
           <h1 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50">
             Asset version:
           </h1>
-          <h2 class="pb-xs text-sm">{{ proto.schemaVariant }}</h2>
+          <h2 class="pb-xs text-sm">
+            {{
+              componentStore.schemaVariantsById[bind.schemaVariantId || ""]
+                ?.version || "N/A"
+            }}
+          </h2>
 
-          <h1 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50">
+          <!--<h1 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50">
             Component:
           </h1>
-          <h2 class="pb-xs text-sm">{{ proto.component }}</h2>
+          <h2 class="pb-xs text-sm">{{ componentStore.componentsById[bind.componentId || ""]
+                ?.displayName || "N/A" }}</h2>-->
 
           <h1 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50">
             Output location:
           </h1>
           <h2 class="pb-xs text-sm">
-            {{ proto.outputLocation?.label ?? "no output location set" }}
+            {{ bind.outputDescription }}
           </h2>
 
           <h1 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50">
@@ -44,13 +55,16 @@
             Below is the source of the data for each function argument listed.
           </h2>
           <ul>
-            <li v-for="arg in proto.args" :key="arg.name">
+            <li v-for="arg in bind.argumentBindings" :key="arg.funcArgumentId">
               <h1
+                v-if="arg.propId"
                 class="pt-xs text-neutral-700 type-bold-sm dark:text-neutral-50"
               >
-                {{ arg.name }}
+                {{ getPropPathFrom(bind.schemaVariantId, arg.propId) }}
               </h1>
-              <h2 class="pb-xs text-sm">{{ arg.path }}</h2>
+              <h2 v-if="arg.inputSocketId" class="pb-xs text-sm">
+                {{ getSocketNameFrom(bind.schemaVariantId, arg.inputSocketId) }}
+              </h2>
             </li>
           </ul>
           <div class="w-full flex p-xs gap-1 border-b dark:border-neutral-600">
@@ -59,31 +73,31 @@
               tone="neutral"
               label="Edit Binding"
               size="md"
-              @click="openModal(proto.id)"
+              @click="openModal(bind)"
             />
             <VButton
-              v-if="!schemaVariantId"
               :disabled="disabled"
               variant="transparent"
               tone="destructive"
               icon="x"
               label="Remove Binding"
               size="md"
-              @click="removeBinding(proto.id)"
+              @click="removeBinding(bind)"
             />
           </div>
         </li>
 
         <AttributeBindingsModal
           ref="bindingsModalRef"
-          :schemaVariantId="schemaVariantId"
+          :funcId="$props.funcId"
+          :schemaVariantId="$props.schemaVariantId"
           type="save"
           @save="saveModal"
         />
       </ul>
     </template>
     <template v-else>
-      <div v-if="schemaVariantId">
+      <div v-if="$props.schemaVariantId">
         <p class="text-neutral-400 dark:text-neutral-300 text-sm p-xs">
           This function is not attached to this schema variant. Use the Attach
           Existing functionality to re-attach it.
@@ -98,93 +112,103 @@
 import { computed, ref } from "vue";
 import { VButton } from "@si/vue-lib/design-system";
 import {
-  AttributeAssociations,
-  AttributePrototypeBag,
-} from "@/store/func/types";
+  FuncId,
+  Attribute,
+  FuncBindingKind,
+  AttributePrototypeId,
+} from "@/api/sdf/dal/func";
+import { PropId } from "@/api/sdf/dal/prop";
+import { OutputSocketId, SchemaVariantId } from "@/api/sdf/dal/schema";
 import { useFuncStore } from "@/store/func/funcs.store";
-import { nilId } from "@/utils/nilId";
 import { useComponentsStore } from "@/store/components.store";
+import { nonNullable } from "@/utils/typescriptLinter";
 import AttributeBindingsModal from "./AttributeBindingsModal.vue";
 
 const funcStore = useFuncStore();
 const componentStore = useComponentsStore();
 
 const props = defineProps<{
-  modelValue: AttributeAssociations;
-  schemaVariantId?: string;
+  funcId: FuncId;
+  schemaVariantId?: SchemaVariantId;
   disabled?: boolean;
 }>();
 
 const bindingsModalRef = ref<InstanceType<typeof AttributeBindingsModal>>();
 
-const funcArguments = computed(() => funcStore.funcArguments);
-const funcId = computed(() => funcStore.selectedFuncId);
-
-const associations = computed(
-  () =>
-    funcStore.funcDetailsById[funcId.value as string]
-      ?.associations as AttributeAssociations,
-);
+const binding = computed(() => {
+  if (!props.schemaVariantId) return null;
 
-const makeEmptyPrototype = (): AttributePrototypeBag => ({
-  id: nilId(),
-  componentId: nilId(),
-  propId: nilId(),
-  prototypeArguments: funcArguments.value
-    ? funcArguments.value.map(({ id }) => ({
-        funcArgumentId: id,
-      }))
-    : [],
+  const bindings = funcStore.attributeBindings[props.funcId];
+  const binding = bindings
+    ?.filter((b) => b.schemaVariantId === props.schemaVariantId)
+    .pop();
+  return binding;
 });
 
-const rehydratePrototype = (
-  existing: AttributePrototypeBag,
-): AttributePrototypeBag => ({
-  id: existing.id,
-  componentId: existing.componentId,
-  propId: existing.propId,
-  prototypeArguments: funcArguments.value
-    ? funcArguments.value.map(({ id }) => {
-        const foundArg = existing.prototypeArguments.find(
-          (protoArg) => protoArg.funcArgumentId === id,
-        );
-        if (foundArg) {
-          return {
-            id: foundArg.id ?? nilId(),
-            funcArgumentId: id,
-            propId: foundArg.propId,
-            inputSocketId: foundArg.inputSocketId,
-          };
-        }
-        return { funcArgumentId: id };
-      })
-    : [],
+const getPropPathFrom = (
+  schemaVariantId: SchemaVariantId | null,
+  propId: PropId,
+) => {
+  return componentStore.schemaVariantsById[schemaVariantId || ""]?.props.find(
+    (p) => (p.id === propId ? p : null),
+  )?.path;
+};
+
+const getSocketNameFrom = (
+  schemaVariantId: SchemaVariantId | null,
+  outputSocketId: OutputSocketId,
+) => {
+  return componentStore.schemaVariantsById[
+    schemaVariantId || ""
+  ]?.outputSockets.find((o) => (o.id === outputSocketId ? o : null))?.name;
+};
+
+interface ExtendedBinding extends Attribute {
+  outputDescription: string;
+  attributePrototypeId: AttributePrototypeId;
+}
+const bindings = computed(() => {
+  let b;
+  if (props.schemaVariantId) b = [binding.value];
+  else {
+    b = funcStore.attributeBindings[props.funcId];
+  }
+  b = ((b as ExtendedBinding[]) || []).filter(nonNullable);
+  return b.map((_b) => {
+    if (_b.outputSocketId) {
+      _b.outputDescription =
+        getSocketNameFrom(_b.schemaVariantId, _b.outputSocketId) || "N/A";
+    }
+    if (_b.propId) {
+      _b.outputDescription =
+        getPropPathFrom(_b.schemaVariantId, _b.propId) || "N/A";
+    }
+    return _b;
+  });
 });
 
-const removeBinding = async (prototypeId: string) => {
-  await funcStore.REMOVE_ATTRIBUTE_PROTOTYPE(prototypeId);
+const makeBinding = () => {
+  return {
+    bindingKind: FuncBindingKind.Attribute,
+    funcId: props.funcId,
+    attributePrototypeId: null,
+    schemaVariantId: props.schemaVariantId,
+    componentId: null,
+    propId: null,
+    outputSocketId: null,
+    argumentBindings: [],
+  } as Attribute;
 };
 
-const addOrUpdateBinding = async (prototype: AttributePrototypeBag) => {
-  if (prototype.id !== nilId()) {
-    // update prototype
-    await funcStore.UPDATE_ATTRIBUTE_PROTOTYPE(
-      funcId.value as string,
-      prototype.id as string,
-      prototype.prototypeArguments,
-      prototype.propId,
-      prototype.outputSocketId,
-    );
+const removeBinding = async (binding: Attribute) => {
+  await funcStore.RESET_ATTRIBUTE_BINDING(props.funcId, [binding]);
+};
+
+const addOrUpdateBinding = async (binding: Attribute) => {
+  if (binding.attributePrototypeId) {
+    await funcStore.UPDATE_BINDING(props.funcId, [binding]);
   } else {
-    // create new prototype
-    await funcStore.CREATE_ATTRIBUTE_PROTOTYPE(
-      funcId.value as string,
-      prototype.schemaVariantId as string,
-      prototype.prototypeArguments,
-      prototype.componentId,
-      prototype.propId,
-      prototype.outputSocketId,
-    );
+    await funcStore.CREATE_BINDING(props.funcId, [binding]);
   }
 };
 
@@ -192,96 +216,22 @@ const closeModal = () => {
   bindingsModalRef.value?.close();
 };
 
-const saveModal = (prototype?: AttributePrototypeBag) => {
-  if (prototype) {
-    addOrUpdateBinding(prototype);
+const saveModal = (binding?: Attribute) => {
+  if (binding) {
+    addOrUpdateBinding(binding);
   }
   closeModal();
 };
 
-const openModal = (prototypeId?: string) => {
-  const prototype = prototypeId
-    ? associations.value.prototypes.find((proto) => proto.id === prototypeId)
-    : makeEmptyPrototype();
+const openModal = (binding?: Attribute) => {
+  if (!binding) binding = makeBinding();
 
-  if (prototype) {
-    const proto = rehydratePrototype(prototype);
-    bindingsModalRef.value?.open(proto);
-  }
+  bindingsModalRef.value?.open(binding);
 };
 
-const prototypeViews = computed(() => {
-  const validPrototypes = associations.value.prototypes.filter((proto) => {
-    // If no sv id on component, don't filter at all
-    if (props.schemaVariantId === undefined) {
-      return true;
-    }
-
-    const schemaVariantId =
-      funcStore.schemaVariantIdForPrototypeTargetId[
-        proto.propId ?? proto.outputSocketId ?? ""
-      ];
-
-    return schemaVariantId === props.schemaVariantId;
-  });
-
-  return validPrototypes.map((proto) => {
-    const schemaVariantId =
-      funcStore.schemaVariantIdForPrototypeTargetId[
-        proto.propId ?? proto.outputSocketId ?? ""
-      ];
-
-    const schemaVariant =
-      componentStore.schemaVariantsById[schemaVariantId ?? ""];
-    const name = schemaVariant?.displayName || "none";
-    const schema = schemaVariant?.schemaName || "none";
-    const component =
-      funcStore.componentOptions.find((c) => c.value === proto.componentId)
-        ?.label ?? "all";
-
-    const outputLocation = funcStore.outputLocationForAttributePrototype(proto);
-    const args = funcStore.funcArguments?.map((funcArg) => ({
-      name: funcArg.name,
-      path: (() => {
-        const protoArg = proto.prototypeArguments.find(
-          (protoArg) => protoArg.funcArgumentId === funcArg.id,
-        );
-        if (protoArg) {
-          return (
-            funcStore.propIdToSourceName(protoArg.propId ?? nilId()) ??
-            funcStore.inputSocketIdToSourceName(
-              protoArg.inputSocketId ?? nilId(),
-            ) ??
-            "none"
-          );
-        }
-        return "none";
-      })(),
-    }));
-
-    return {
-      id: proto.id,
-      schema,
-      schemaVariant: name,
-      component,
-      outputLocation,
-      args,
-    };
-  });
-});
-
-const detachFunc = async (): Promise<undefined> => {
-  if (props.schemaVariantId) {
-    const prototype = associations.value.prototypes.find(
-      (proto) =>
-        funcStore.schemaVariantIdForPrototypeTargetId[
-          proto.propId ?? proto.outputSocketId ?? ""
-        ] === props.schemaVariantId,
-    );
-    // todo: remove the binding when the user hits the detach button
-    await removeBinding(prototype?.id as string);
-    return;
-  }
+const detachFunc = async () => {
+  if (binding.value)
+    funcStore.RESET_ATTRIBUTE_BINDING(props.funcId, [binding.value]);
 };
 
 defineExpose({ detachFunc });
diff --git a/app/web/src/components/FuncEditor/AttributeBindingsModal.vue b/app/web/src/components/FuncEditor/AttributeBindingsModal.vue
index 22608cc094..88fd4ba642 100644
--- a/app/web/src/components/FuncEditor/AttributeBindingsModal.vue
+++ b/app/web/src/components/FuncEditor/AttributeBindingsModal.vue
@@ -8,22 +8,15 @@
     @save="emit('save', editedPrototype)"
   >
     <div class="p-4 flex flex-col place-content-center">
-      <template v-if="!schemaVariantId">
+      <template v-if="isCreating">
         <h1 class="pt-2 text-neutral-700 type-bold-sm dark:text-neutral-50">
           Asset:
         </h1>
         <SelectMenu
           v-model="selectedVariant"
           class="flex-auto"
-          :options="schemaVariantOptions ?? []"
-        />
-        <h1 class="pt-2 text-neutral-700 type-bold-sm dark:text-neutral-50">
-          Component:
-        </h1>
-        <SelectMenu
-          v-model="selectedComponent"
-          class="flex-auto"
-          :options="filteredComponentOptions"
+          :options="schemaVariantOptions"
+          @change="variantChanged"
         />
       </template>
       <h1 class="pt-2 text-neutral-700 type-bold-sm dark:text-neutral-50">
@@ -32,6 +25,7 @@
       <SelectMenu
         v-model="selectedOutputLocation"
         class="flex-auto"
+        :disabled="!isCreating"
         :options="outputLocationOptions"
       />
       <h1 class="pt-2 text-neutral-700 type-bold-sm dark:text-neutral-50">
@@ -53,27 +47,32 @@
 </template>
 
 <script lang="ts" setup>
-import { watch, computed, ref } from "vue";
+import { computed, ref, ComputedRef } from "vue";
 import { storeToRefs } from "pinia";
 import { Modal, useModal } from "@si/vue-lib/design-system";
 import SelectMenu, { Option } from "@/components/SelectMenu.vue";
-import { AttributePrototypeBag, OutputLocation } from "@/store/func/types";
-import { FuncArgumentId } from "@/api/sdf/dal/func";
-import { useFuncStore, OutputLocationOption } from "@/store/func/funcs.store";
+import {
+  FuncArgumentId,
+  Attribute,
+  FuncBindingKind,
+  FuncId,
+  AttributePrototypeArgumentId,
+} from "@/api/sdf/dal/func";
+import {
+  outputSocketsAndPropsFor,
+  inputSocketsAndPropsFor,
+} from "@/api/sdf/dal/schema";
+import { useFuncStore } from "@/store/func/funcs.store";
 import { useComponentsStore } from "@/store/components.store";
-
-function nilId(): string {
-  return "00000000000000000000000000";
-}
+import { nilId } from "@/utils/nilId";
 
 const componentsStore = useComponentsStore();
-const { allComponents } = storeToRefs(componentsStore);
+const { schemaVariantOptions } = storeToRefs(componentsStore);
 
 const funcStore = useFuncStore();
-const { schemaVariantOptions } = storeToRefs(funcStore);
 
 const props = defineProps<{
-  schemaVariantId?: string;
+  funcId: FuncId;
 }>();
 
 const bindingsModalRef = ref<InstanceType<typeof Modal>>();
@@ -86,199 +85,139 @@ const modalTitle = computed(
 
 const emit = defineEmits<{
   (e: "close"): void;
-  (e: "save", v?: AttributePrototypeBag): void;
+  (e: "save", v?: Attribute): void;
 }>();
 
 interface EditingBinding {
   id?: string;
   funcArgumentId: string;
+  attributePrototypeArgumentId: AttributePrototypeArgumentId | null;
   binding: Option;
 }
 
-const allComponentsOption = {
-  label: "All components for schema variant",
-  value: nilId(),
-};
-const noneVariant = { label: "select schema variant", value: nilId() };
 const noneOutputLocation = {
   label: "select place to store output",
-  value: { label: "", propId: nilId() },
+  value: nilId(),
 };
 const noneSource = { label: "select source", value: nilId() };
 
-const selectedVariant = ref<Option>(
-  props.schemaVariantId
-    ? { label: "", value: props.schemaVariantId }
-    : noneVariant,
-);
-const selectedComponent = ref<Option>(allComponentsOption);
-const selectedOutputLocation = ref<OutputLocationOption>(noneOutputLocation);
+const selectedOutputLocation = ref<Option>(noneOutputLocation);
 const editableBindings = ref<EditingBinding[]>([]);
 
-const prototypeId = ref<string | undefined>();
-
-const funcArgumentsById = computed(() => funcStore.funcArgumentsById);
+const openedWithBinding = ref<Attribute | null>(null);
+const noneVariant = { label: "select schema variant", value: nilId() };
+const selectedVariant = ref<Option>(noneVariant);
 
 const funcArgumentName = (
   funcArgumentId: FuncArgumentId,
 ): string | undefined => {
-  return funcArgumentsById.value[funcArgumentId]?.name;
+  return funcStore.selectedFuncSummary?.arguments
+    .filter((a) => a.id === funcArgumentId)
+    .pop()?.name;
 };
 
-const editedPrototype = computed(() => ({
-  id: prototypeId.value ?? nilId(),
-  schemaVariantId: selectedVariant.value.value as string,
-  componentId: selectedComponent.value.value as string,
-  propId:
-    "propId" in selectedOutputLocation.value.value
-      ? selectedOutputLocation.value.value.propId
-      : undefined,
-  outputSocketId:
-    "outputSocketId" in selectedOutputLocation.value.value
-      ? selectedOutputLocation.value.value.outputSocketId
-      : undefined,
-  prototypeArguments: editableBindings.value.map(
-    ({ id, funcArgumentId, binding }) => ({
-      id: id ?? nilId(),
-      funcArgumentId: funcArgumentId ?? nilId(),
+const editedPrototype: ComputedRef<Attribute> = computed(() => ({
+  bindingKind: FuncBindingKind.Attribute,
+  attributePrototypeId: openedWithBinding.value?.attributePrototypeId || null,
+  componentId: null,
+  funcId: props.funcId,
+  schemaVariantId: selectedVariant.value?.value as string,
+  propId: (selectedOutputLocation.value.value as string).startsWith("p_")
+    ? (selectedOutputLocation.value.value as string).replace("p_", "")
+    : null,
+  outputSocketId: (selectedOutputLocation.value.value as string).startsWith(
+    "s_",
+  )
+    ? (selectedOutputLocation.value.value as string).replace("s_", "")
+    : null,
+  argumentBindings: editableBindings.value.map(
+    ({ funcArgumentId, attributePrototypeArgumentId, binding }) => ({
+      funcArgumentId: funcArgumentId ?? null,
       inputSocketId: binding.label.includes("Input Socket")
-        ? (binding.value as string)
-        : undefined,
+        ? (binding.value as string).replace("s_", "")
+        : null,
       propId: binding.label.includes("Attribute")
-        ? (binding.value as string)
-        : undefined,
+        ? (binding.value as string).replace("p_", "")
+        : null,
+      attributePrototypeArgumentId,
     }),
   ),
 }));
 
-const filteredComponentOptions = computed<Option[]>(() =>
-  [allComponentsOption].concat(
-    allComponents.value
-      .filter(
-        (c) =>
-          selectedVariant.value.value === nilId() ||
-          c.schemaVariantId === selectedVariant.value.value,
-      )
-      .map(({ displayName, id }) => ({
-        label: displayName,
-        value: id,
-      })) ?? [],
-  ),
-);
+const outputLocationOptions = computed(() => {
+  let socketOptions: Option[] = [];
+  let propOptions: Option[] = [];
+  const variant =
+    componentsStore.schemaVariantsById[selectedVariant.value.value as string];
+  if (variant)
+    ({ socketOptions, propOptions } = outputSocketsAndPropsFor(variant));
 
-const outputLocationOptions = computed<
-  { label: string; value: OutputLocation }[]
->(() =>
-  funcStore.outputLocationOptionsForSchemaVariant(
-    props.schemaVariantId ??
-      (typeof selectedVariant.value.value === "string"
-        ? selectedVariant.value.value
-        : nilId()),
-  ),
-);
-
-const inputSourceOptions = computed<Option[]>(() => {
-  const selectedVariantId = selectedVariant.value.value as number;
-  const socketOptions =
-    funcStore.inputSourceSockets[selectedVariantId]?.map((socket) => ({
-      label: `Input Socket: ${socket.name}`,
-      value: socket.inputSocketId,
-    })) ?? [];
-
-  const propOptions =
-    funcStore.inputSourceProps[selectedVariantId]?.map((prop) => ({
-      label: `Attribute: ${prop.path}`,
-      value: prop.propId,
-    })) ?? [];
-
-  return socketOptions.concat(propOptions);
+  return [...socketOptions, ...propOptions];
 });
 
-// When variant changes, unset component if necessary
-watch(selectedVariant, (selectedVariant) => {
-  const componentIdent = allComponents.value.find(
-    (c) => c.id === selectedComponent.value.value,
-  );
-
-  if (componentIdent?.schemaVariantId !== selectedVariant.value) {
-    selectedComponent.value = allComponentsOption;
-  }
-
-  const propId =
-    "propId" in selectedOutputLocation.value.value
-      ? selectedOutputLocation.value.value.propId
-      : undefined;
-
-  const socketId =
-    "outputSocketId" in selectedOutputLocation.value.value
-      ? selectedOutputLocation.value.value.outputSocketId
-      : undefined;
-
-  const targetId = propId ?? socketId;
-
-  const currentSchemaVariantId =
-    funcStore.schemaVariantIdForPrototypeTargetId[targetId ?? ""];
+const inputSourceOptions = computed(() => {
+  let socketOptions: Option[] = [];
+  let propOptions: Option[] = [];
+  const variant =
+    componentsStore.schemaVariantsById[selectedVariant.value.value as string];
+  if (variant)
+    ({ socketOptions, propOptions } = inputSocketsAndPropsFor(variant));
 
-  if ((selectedVariant.value as string) !== currentSchemaVariantId) {
-    selectedOutputLocation.value = noneOutputLocation;
-  }
+  return [...socketOptions, ...propOptions];
 });
 
-// When component changes, ensure variant is set correctly
-watch(
-  selectedComponent,
-  (selectedComponent) => {
-    const componentIdent = allComponents.value.find(
-      (c) => c.id === selectedComponent.value,
-    );
-    if (
-      componentIdent &&
-      selectedVariant.value.value !== componentIdent.schemaVariantId
-    ) {
-      selectedVariant.value =
-        schemaVariantOptions?.value.find(
-          (sv) => sv.value === componentIdent?.schemaVariantId,
-        ) ?? noneVariant;
-    }
-  },
-  { immediate: true },
-);
+const variantChanged = () => {
+  selectedOutputLocation.value = noneOutputLocation;
+};
 
 // When prototype we're editing changes, set up defaults
-const open = (prototype: AttributePrototypeBag) => {
-  const targetId = prototype.propId ?? prototype.outputSocketId ?? "";
-
-  const schemaVariantId =
-    props.schemaVariantId ??
-    funcStore.schemaVariantIdForPrototypeTargetId[targetId];
-
-  prototypeId.value = prototype.id;
+const open = (binding: Attribute) => {
+  isCreating.value = !binding.attributePrototypeId;
+  openedWithBinding.value = binding;
 
+  const startingVariant =
+    componentsStore.schemaVariantsById[binding.schemaVariantId || ""];
   selectedVariant.value =
-    schemaVariantOptions?.value.find((sv) => sv.value === schemaVariantId) ??
-    noneVariant;
-  selectedComponent.value =
-    filteredComponentOptions.value.find((c) => c.value === prototype.id) ??
-    allComponentsOption;
+    schemaVariantOptions.value.find(
+      (o) => o.value === startingVariant?.schemaVariantId,
+    ) || noneVariant;
+
   selectedOutputLocation.value =
     outputLocationOptions.value.find(
       (loc) =>
-        ("propId" in loc.value && loc.value.propId === prototype.propId) ||
-        ("outputSocketId" in loc.value &&
-          loc.value.outputSocketId === prototype.outputSocketId),
-    ) ?? noneOutputLocation;
-
-  editableBindings.value =
-    prototype?.prototypeArguments.map(
-      ({ id, funcArgumentId, inputSocketId, propId }) => ({
-        id: id ?? undefined,
-        funcArgumentId,
-        binding:
-          inputSourceOptions.value.find(
-            (opt) => opt.value === inputSocketId || opt.value === propId,
-          ) ?? noneSource,
-      }),
-    ) ?? [];
+        loc.value === `p_${binding.propId}` ||
+        loc.value === `s_${binding.outputSocketId}`,
+    ) || noneOutputLocation;
+
+  editableBindings.value = [];
+  if (binding.argumentBindings.length > 0) {
+    editableBindings.value =
+      binding?.argumentBindings.map(
+        ({
+          funcArgumentId,
+          attributePrototypeArgumentId,
+          inputSocketId,
+          propId,
+        }) => ({
+          funcArgumentId,
+          attributePrototypeArgumentId,
+          binding:
+            inputSourceOptions.value.find(
+              (opt) =>
+                opt.value === `s_${inputSocketId}` ||
+                opt.value === `p_${propId}`,
+            ) || noneSource,
+        }),
+      ) || [];
+  } else {
+    const funcArgs = funcStore.funcsById[props.funcId]?.arguments;
+    if (funcArgs)
+      editableBindings.value = funcArgs.map(({ id }) => ({
+        funcArgumentId: id,
+        attributePrototypeArgumentId: null,
+        binding: noneSource,
+      }));
+  }
 
   openModal();
 };
diff --git a/app/web/src/components/FuncEditor/AuthenticationDetails.vue b/app/web/src/components/FuncEditor/AuthenticationDetails.vue
index e81b0c8267..efdfeb2380 100644
--- a/app/web/src/components/FuncEditor/AuthenticationDetails.vue
+++ b/app/web/src/components/FuncEditor/AuthenticationDetails.vue
@@ -1,85 +1,59 @@
 <template>
   <div class="p-3 flex flex-col gap-xs">
-    <template v-if="!schemaVariantId">
-      <h1 class="text-neutral-400 dark:text-neutral-300 text-sm">
-        Run this authentication function on components that use the secret kind
-        defined by the component types below.
-      </h1>
-      <h2 class="pt-4 text-neutral-700 type-bold-sm dark:text-neutral-50">
-        Run on Schema Variant:
-      </h2>
-      <RunOnSelector
-        v-model="selectedVariants"
-        thingLabel="schema variants"
-        :options="schemaVariantOptions"
-        @change="updateAssociations"
-      />
-    </template>
+    <p class="text-sm">You can detach this function above.</p>
   </div>
 </template>
 
 <script lang="ts" setup>
-import { ref, toRef, watch } from "vue";
+import { ref, computed, watch } from "vue";
 import { storeToRefs } from "pinia";
 import { Option } from "@/components/SelectMenu.vue";
-import {
-  AuthenticationAssociations,
-  FuncAssociations,
-} from "@/store/func/types";
+import { FuncId } from "@/api/sdf/dal/func";
+import { SchemaVariantId } from "@/api/sdf/dal/schema";
 import { toOptionValues } from "@/components/FuncEditor/utils";
 import { useFuncStore } from "@/store/func/funcs.store";
-import RunOnSelector from "./RunOnSelector.vue";
+import { useComponentsStore } from "@/store/components.store";
+import { nonNullable } from "@/utils/typescriptLinter";
 
 const funcStore = useFuncStore();
-const { componentOptions, schemaVariantOptions } = storeToRefs(funcStore);
+const componentsStore = useComponentsStore();
+const { schemaVariantOptions } = storeToRefs(componentsStore);
 
 const props = defineProps<{
-  modelValue: AuthenticationAssociations;
-  schemaVariantId?: string;
+  funcId: FuncId;
+  schemaVariantId?: SchemaVariantId;
 }>();
 
-const modelValue = toRef(props, "modelValue");
+const binding = computed(() => {
+  const bindings = funcStore.authenticationBindings[props.funcId];
+  const binding = bindings
+    ?.filter((b) => b.schemaVariantId === props.schemaVariantId)
+    .pop();
+  return binding;
+});
+
+const validSchemaVariantIds = computed(() => {
+  const bindings = funcStore.actionBindings[props.funcId];
+  return bindings?.map((b) => b.schemaVariantId).filter(nonNullable);
+});
 
 const selectedVariants = ref<Option[]>(
-  toOptionValues(schemaVariantOptions.value, modelValue.value.schemaVariantIds),
+  toOptionValues(schemaVariantOptions.value, validSchemaVariantIds.value || []),
 );
 
-const emit = defineEmits<{
-  (e: "update:modelValue", v: AuthenticationAssociations): void;
-  (e: "change", v: AuthenticationAssociations): void;
-}>();
-
 watch(
-  [modelValue, schemaVariantOptions, componentOptions],
-  ([mv, svOpts]) => {
-    selectedVariants.value = toOptionValues(svOpts, mv.schemaVariantIds);
+  [validSchemaVariantIds, schemaVariantOptions],
+  () => {
+    selectedVariants.value = toOptionValues(
+      schemaVariantOptions.value,
+      validSchemaVariantIds.value || [],
+    );
   },
   { immediate: true },
 );
 
-const getUpdatedAssociations = (
-  schemaVariantIds: string[],
-): AuthenticationAssociations => ({
-  schemaVariantIds,
-  type: "authentication",
-});
-
-const updateAssociations = () => {
-  const associations = getUpdatedAssociations(
-    selectedVariants.value.map(({ value }) => value as string),
-  );
-  emit("update:modelValue", associations);
-  emit("change", associations);
-};
-
-const detachFunc = (): FuncAssociations | undefined => {
-  if (props.schemaVariantId) {
-    return getUpdatedAssociations(
-      selectedVariants.value
-        .map(({ value }) => value as string)
-        .filter((schemaVariantId) => schemaVariantId !== props.schemaVariantId),
-    );
-  }
+const detachFunc = () => {
+  if (binding.value) funcStore.DELETE_BINDING(props.funcId, [binding.value]);
 };
 
 defineExpose({ detachFunc });
diff --git a/app/web/src/components/FuncEditor/CodeGenerationDetails.vue b/app/web/src/components/FuncEditor/CodeGenerationDetails.vue
index 59fd3521cf..5567bcf91b 100644
--- a/app/web/src/components/FuncEditor/CodeGenerationDetails.vue
+++ b/app/web/src/components/FuncEditor/CodeGenerationDetails.vue
@@ -1,106 +1,42 @@
 <template>
   <div class="p-xs flex flex-col gap-xs">
-    <template v-if="!schemaVariantId">
-      <h1 class="text-neutral-400 dark:text-neutral-300 text-sm">
-        Run this code generation function on the selected components and
-        component types below.
-      </h1>
-      <h2 class="pt-2xs text-neutral-700 type-bold-sm dark:text-neutral-50">
-        Run on Component:
-      </h2>
-      <RunOnSelector
-        v-model="selectedComponents"
-        thingLabel="components"
-        :options="componentOptions"
-        @change="updateAssociations"
-      />
-      <h2 class="pt-2xs text-neutral-700 type-bold-sm dark:text-neutral-50">
-        Run on Schema Variant:
-      </h2>
-      <RunOnSelector
-        v-model="selectedVariants"
-        thingLabel="schema variants"
-        :options="schemaVariantOptions"
-        @change="updateAssociations"
-      />
-    </template>
-    <LeafInputs v-model="inputs" @change="updateAssociations" />
+    <LeafInputs v-model="inputs" @change="update" />
   </div>
 </template>
 
 <script lang="ts" setup>
-import { ref, watch, toRef } from "vue";
-import { storeToRefs } from "pinia";
-import { Option } from "@/components/SelectMenu.vue";
-import {
-  CodeGenerationAssociations,
-  FuncAssociations,
-} from "@/store/func/types";
-import { toOptionValues } from "@/components/FuncEditor/utils";
+import { ref, computed } from "vue";
+import * as _ from "lodash-es";
 import { useFuncStore } from "@/store/func/funcs.store";
-import RunOnSelector from "./RunOnSelector.vue";
 import LeafInputs from "./LeafInputs.vue";
 
 const funcStore = useFuncStore();
-const { componentOptions, schemaVariantOptions } = storeToRefs(funcStore);
 
 const props = defineProps<{
-  modelValue: CodeGenerationAssociations;
-  schemaVariantId?: string;
+  schemaVariantId: string;
+  funcId: string;
 }>();
 
-const modelValue = toRef(props, "modelValue");
-
-const selectedVariants = ref<Option[]>(
-  toOptionValues(schemaVariantOptions.value, modelValue.value.schemaVariantIds),
-);
-const selectedComponents = ref<Option[]>(
-  toOptionValues(componentOptions.value, modelValue.value.componentIds),
-);
-
-const inputs = ref(modelValue.value.inputs);
-
-const emit = defineEmits<{
-  (e: "update:modelValue", v: CodeGenerationAssociations): void;
-  (e: "change", v: CodeGenerationAssociations): void;
-}>();
-
-watch(
-  [modelValue, schemaVariantOptions, componentOptions],
-  ([mv, svOpts, componentOpts]) => {
-    selectedVariants.value = toOptionValues(svOpts, mv.schemaVariantIds);
-    selectedComponents.value = toOptionValues(componentOpts, mv.componentIds);
-    inputs.value = mv.inputs;
-  },
-  { immediate: true },
-);
-
-const getUpdatedAssocations = (
-  schemaVariantIds: string[],
-): CodeGenerationAssociations => ({
-  componentIds: selectedComponents.value.map(({ value }) => value as string),
-  schemaVariantIds,
-  inputs: inputs.value,
-  type: "codeGeneration",
+const binding = computed(() => {
+  const bindings = funcStore.codegenBindings[props.funcId];
+  const binding = bindings
+    ?.filter((b) => b.schemaVariantId === props.schemaVariantId)
+    .pop();
+  return binding;
 });
 
-const updateAssociations = () => {
-  const associations = getUpdatedAssocations(
-    selectedVariants.value.map(({ value }) => value as string),
-  );
-  emit("update:modelValue", associations);
-  emit("change", associations);
-};
+const inputs = ref(_.clone(binding.value?.inputs) || []);
 
-const detachFunc = (): FuncAssociations | undefined => {
-  if (props.schemaVariantId) {
-    return getUpdatedAssocations(
-      selectedVariants.value
-        .map(({ value }) => value as string)
-        .filter((schemaVariantId) => schemaVariantId !== props.schemaVariantId),
-    );
+const update = () => {
+  if (binding.value) {
+    binding.value.inputs = _.clone(inputs.value);
+    funcStore.UPDATE_BINDING(props.funcId, [binding.value]);
   }
 };
 
+const detachFunc = () => {
+  if (binding.value) funcStore.DELETE_BINDING(props.funcId, [binding.value]);
+};
+
 defineExpose({ detachFunc });
 </script>
diff --git a/app/web/src/components/FuncEditor/FuncArguments.vue b/app/web/src/components/FuncEditor/FuncArguments.vue
index a650bc3e85..eb7d92237a 100644
--- a/app/web/src/components/FuncEditor/FuncArguments.vue
+++ b/app/web/src/components/FuncEditor/FuncArguments.vue
@@ -18,14 +18,6 @@
         noLabel
         type="dropdown"
         :options="kindOptions"
-        @change="
-          updateArgument(
-            newArg.id,
-            newArg.name,
-            newArg.kind,
-            newArg.elementKind,
-          )
-        "
       />
       <VButton
         icon="plus"
@@ -42,13 +34,12 @@
         class="flex flex-row items-center gap-2xs"
       >
         <VormInput
-          :id="`arg-name-${arg.id}`"
           v-model="arg.name"
           type="text"
           noLabel
           placeholder="Argument name"
           :disabled="disabled"
-          @blur="updateArgument(arg.id, arg.name, arg.kind, arg.elementKind)"
+          @blur="updateArgument(arg)"
         />
         <VormInput
           v-model="arg.kind"
@@ -56,7 +47,7 @@
           noLabel
           type="dropdown"
           :options="kindOptions"
-          @change="updateArgument(arg.id, arg.name, arg.kind, arg.elementKind)"
+          @change="updateArgument(arg)"
         />
         <VButton
           icon="trash"
@@ -71,11 +62,12 @@
 </template>
 
 <script lang="ts" setup>
-import { computed, onMounted, ref } from "vue";
+import { computed, ref } from "vue";
 import { VButton, VormInput } from "@si/vue-lib/design-system";
 import { FuncArgument, FuncArgumentKind } from "@/api/sdf/dal/func";
 import { Option } from "@/components/SelectMenu.vue";
 import { useFuncStore } from "@/store/func/funcs.store";
+import { nilId } from "@/utils/nilId";
 
 const props = defineProps<{
   funcId: string;
@@ -87,19 +79,19 @@ const funcsStore = useFuncStore();
 const generateKindOptions = () => {
   const options: Option[] = [];
   for (const kind in FuncArgumentKind) {
-    options.push({ label: kind, value: kind });
+    options.push({ label: kind, value: kind.toLowerCase() });
   }
   return options;
 };
 
 const kindOptions = generateKindOptions();
-// we haven't implemented element kinds yet
-// const elementKindOptions = [kindToOption()].concat(generateKindOptions());
 
 const newArg = ref<FuncArgument>({
-  id: "",
+  id: nilId(),
   name: "",
   kind: FuncArgumentKind.String,
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
 });
 
 const resetNewArg = () => {
@@ -108,40 +100,20 @@ const resetNewArg = () => {
 };
 
 const createArgument = async () => {
-  await funcsStore.CREATE_FUNC_ARGUMENT(
-    props.funcId,
-    newArg.value.name,
-    newArg.value.kind,
-    newArg.value.elementKind,
-  );
+  await funcsStore.CREATE_FUNC_ARGUMENT(props.funcId, newArg.value);
 
   resetNewArg();
 };
 
-const updateArgument = async (
-  funcArgumentId: string,
-  name: string,
-  kind: FuncArgumentKind,
-  elementKind?: FuncArgumentKind,
-) => {
-  await funcsStore.UPDATE_FUNC_ARGUMENT(
-    props.funcId,
-    funcArgumentId,
-    name,
-    kind,
-    elementKind,
-  );
+const updateArgument = async (arg: FuncArgument) => {
+  await funcsStore.UPDATE_FUNC_ARGUMENT(props.funcId, arg);
 };
 
 const funcArguments = computed(
-  () => funcsStore.funcArgumentsByFuncId[props.funcId],
+  () => funcsStore.funcsById[props.funcId]?.arguments,
 );
 
 const deleteArgument = async (funcArgumentId: string) => {
   await funcsStore.DELETE_FUNC_ARGUMENT(props.funcId, funcArgumentId);
 };
-
-onMounted(() => {
-  funcsStore.FETCH_FUNC_ARGUMENT_LIST(props.funcId);
-});
 </script>
diff --git a/app/web/src/components/FuncEditor/FuncDetails.vue b/app/web/src/components/FuncEditor/FuncDetails.vue
index 9a3efb3008..0038956d69 100644
--- a/app/web/src/components/FuncEditor/FuncDetails.vue
+++ b/app/web/src/components/FuncEditor/FuncDetails.vue
@@ -5,32 +5,31 @@
     primaryText="No Function Selected"
     secondaryText="Select a function from the list on the left panel to view its details here."
   />
-  <LoadingMessage
-    v-else-if="
-      (loadFuncDetailsReqStatus.isPending && !storeFuncDetails) ||
-      !loadFuncDetailsReqStatus.isRequested
-    "
-  >
-    Loading function "{{ selectedFuncSummary?.name }}"
-  </LoadingMessage>
   <div
-    v-else-if="selectedFuncId && editingFunc"
+    v-else-if="selectedFuncSummary && editingFunc"
     :class="clsx('h-full w-full flex flex-col overflow-hidden')"
   >
     <div class="flex flex-col">
-      <ErrorMessage
-        v-if="editingFunc?.associations?.type === 'action'"
-        icon="alert-triangle"
-        tone="warning"
-        variant="block"
-        >Executing this will run on all attached components and may affect your
-        real-world resources!
-      </ErrorMessage>
-      <ErrorMessage
-        v-if="execFuncReqStatus.isError"
-        :requestStatus="execFuncReqStatus"
-        variant="block"
-      />
+      <SidebarSubpanelTitle
+        icon="func"
+        variant="subtitle"
+        :label="selectedFuncSummary.name"
+      >
+        <template v-if="ffStore.IMMUTABLE_SCHEMA_VARIANTS">
+          <EditingPill
+            v-if="!selectedFuncSummary.isLocked"
+            color="#666"
+          ></EditingPill>
+          <IconButton
+            v-else
+            class="hover:scale-125"
+            variant="simple"
+            icon="sliders-vertical"
+            tooltip="Edit"
+            tooltipPlacement="top"
+          />
+        </template>
+      </SidebarSubpanelTitle>
       <ErrorMessage
         v-if="isConnectedToOtherAssetTypes"
         icon="alert-triangle"
@@ -39,19 +38,24 @@
       >
         This function is connected to other
         {{
-          editingFunc?.associations &&
-          editingFunc?.associations?.type === "attribute"
+          selectedFuncSummary.kind === FuncKind.Attribute
             ? "attributes"
             : "assets"
         }}.
       </ErrorMessage>
-
-      <SidebarSubpanelTitle
-        icon="func"
-        :label="selectedFuncSummary?.name"
-        variant="subtitle"
+      <ErrorMessage
+        v-if="selectedFuncSummary.kind === FuncKind.Action"
+        icon="alert-triangle"
+        tone="warning"
+        variant="block"
+        >Executing this will run on all attached components and may affect your
+        real-world resources!
+      </ErrorMessage>
+      <ErrorMessage
+        v-if="execFuncReqStatus.isError"
+        :requestStatus="execFuncReqStatus"
+        variant="block"
       />
-
       <div
         class="flex flex-row gap-2xs items-center justify-evenly py-xs border-b border-neutral-200 dark:border-neutral-600"
       >
@@ -63,13 +67,7 @@
           tooltip="Execute"
           tooltipPlacement="top"
           :requestStatus="execFuncReqStatus"
-          :disabled="
-            !(
-              funcStore.selectedFuncDetails &&
-              funcStore.selectedFuncDetails?.associations?.type !==
-                'authentication'
-            )
-          "
+          :disabled="!(selectedFuncSummary.kind !== FuncKind.Authentication)"
           @click="execFunc"
         />
         <IconButton
@@ -87,7 +85,6 @@
           tooltip="Detach"
           tooltipPlacement="top"
           loadingTooltip="Detaching..."
-          :disabled="!schemaVariantId"
           @click="detachFunc"
         />
         <IconButton
@@ -147,43 +144,32 @@
             </TreeNode>
 
             <ActionDetails
-              v-if="editingFunc.associations?.type === 'action'"
+              v-if="selectedFuncSummary.kind === FuncKind.Action"
               ref="detachRef"
-              v-model="editingFunc.associations"
-              :requestStatus="updateFuncReqStatus"
-              :schemaVariantId="schemaVariantId"
-              @change="updateFunc"
+              :funcId="selectedFuncSummary.funcId"
+              :schemaVariantId="$props.schemaVariantId"
             />
             <AuthenticationDetails
-              v-if="editingFunc.associations?.type === 'authentication'"
+              v-if="selectedFuncSummary.kind === FuncKind.Authentication"
               ref="detachRef"
-              v-model="editingFunc.associations"
-              :schemaVariantId="schemaVariantId"
-              @change="updateFunc"
+              :funcId="selectedFuncSummary.funcId"
+              :schemaVariantId="$props.schemaVariantId"
             />
             <CodeGenerationDetails
-              v-if="
-                editingFunc.associations &&
-                editingFunc.associations.type === 'codeGeneration'
-              "
+              v-if="selectedFuncSummary.kind === FuncKind.CodeGeneration"
               ref="detachRef"
-              v-model="editingFunc.associations"
-              :schemaVariantId="schemaVariantId"
-              @change="updateFunc"
+              :funcId="selectedFuncSummary.funcId"
+              :schemaVariantId="$props.schemaVariantId"
             />
             <QualificationDetails
-              v-if="
-                editingFunc.associations &&
-                editingFunc.associations.type === 'qualification'
-              "
+              v-if="selectedFuncSummary.kind === FuncKind.Qualification"
               ref="detachRef"
-              v-model="editingFunc.associations"
-              :schemaVariantId="schemaVariantId"
-              @change="updateFunc"
+              :funcId="selectedFuncSummary.funcId"
+              :schemaVariantId="$props.schemaVariantId"
             />
 
             <TreeNode
-              v-if="editingFunc.kind === FuncKind.Attribute"
+              v-if="selectedFuncSummary?.kind === FuncKind.Attribute"
               label="Arguments"
               defaultOpen
               enableGroupToggle
@@ -193,17 +179,14 @@
               labelClasses="border-b border-neutral-200 dark:border-neutral-600"
               childrenContainerClasses="border-b border-neutral-200 dark:border-neutral-600"
             >
-              <FuncArguments
-                v-if="
-                  editingFunc.associations &&
-                  editingFunc.associations.type === 'attribute'
-                "
-                :funcId="editingFunc.id"
-              />
+              <FuncArguments :funcId="editingFunc.funcId" />
             </TreeNode>
 
             <TreeNode
-              v-if="editingFunc.kind === FuncKind.Attribute && schemaVariantId"
+              v-if="
+                selectedFuncSummary?.kind === FuncKind.Attribute &&
+                $props.schemaVariantId
+              "
               label="Bindings"
               defaultOpen
               enableGroupToggle
@@ -214,33 +197,23 @@
               childrenContainerClasses="border-b border-neutral-200 dark:border-neutral-600"
             >
               <AttributeBindings
-                v-if="
-                  editingFunc.associations &&
-                  editingFunc.associations.type === 'attribute'
-                "
                 ref="detachRef"
-                v-model="editingFunc.associations"
-                :schemaVariantId="schemaVariantId"
-                @change="updateFunc"
+                :schemaVariantId="$props.schemaVariantId"
+                :funcId="selectedFuncSummary.funcId"
               />
             </TreeNode>
           </div>
         </TabGroupItem>
 
         <TabGroupItem
-          v-if="editingFunc.kind === FuncKind.Attribute"
+          v-if="selectedFuncSummary?.kind === FuncKind.Attribute"
           label="Bindings"
           slug="bindings"
         >
           <AttributeBindings
-            v-if="
-              editingFunc.associations &&
-              editingFunc.associations.type === 'attribute'
-            "
             ref="detachRef"
-            v-model="editingFunc.associations"
+            :funcId="selectedFuncSummary.funcId"
             class="border-t border-neutral-200 dark:border-neutral-600"
-            @change="updateFunc"
           />
         </TabGroupItem>
 
@@ -264,7 +237,6 @@ import { computed, ref, watch } from "vue";
 import { storeToRefs } from "pinia";
 import {
   ErrorMessage,
-  LoadingMessage,
   Stack,
   TabGroup,
   TabGroupItem,
@@ -272,10 +244,16 @@ import {
   VormInput,
 } from "@si/vue-lib/design-system";
 import clsx from "clsx";
-import { FuncKind, FuncId } from "@/api/sdf/dal/func";
+import {
+  FuncKind,
+  FuncId,
+  FuncBinding,
+  FuncBindingKind,
+} from "@/api/sdf/dal/func";
 import { useFuncStore } from "@/store/func/funcs.store";
 import { useAssetStore } from "@/store/asset.store";
 import AuthenticationDetails from "@/components/FuncEditor/AuthenticationDetails.vue";
+import { useFeatureFlagsStore } from "@/store/feature_flags.store";
 import FuncArguments from "./FuncArguments.vue";
 import ActionDetails from "./ActionDetails.vue";
 import AttributeBindings from "./AttributeBindings.vue";
@@ -285,10 +263,11 @@ import FuncTest from "./FuncTest.vue";
 import EmptyStateCard from "../EmptyStateCard.vue";
 import IconButton from "../IconButton.vue";
 import SidebarSubpanelTitle from "../SidebarSubpanelTitle.vue";
+import EditingPill from "../EditingPill.vue";
 
 const props = defineProps<{
-  funcId?: FuncId;
-  schemaVariantId?: string;
+  funcId: FuncId;
+  schemaVariantId: string;
   allowTestPanel?: boolean;
 }>();
 
@@ -296,6 +275,7 @@ const funcDetailsTabGroupRef = ref();
 
 const funcStore = useFuncStore();
 const assetStore = useAssetStore();
+const ffStore = useFeatureFlagsStore();
 
 const emit = defineEmits<{
   (e: "expandPanel"): void;
@@ -310,22 +290,17 @@ type DetachType =
 const detachRef = ref<DetachType>();
 const funcId = computed(() => props.funcId);
 
-const loadFuncDetailsReqStatus = funcStore.getRequestStatus(
-  "FETCH_FUNC",
-  funcId,
-);
 const updateFuncReqStatus = funcStore.getRequestStatus("UPDATE_FUNC", funcId);
-const { selectedFuncId, selectedFuncSummary } = storeToRefs(funcStore);
+const { selectedFuncSummary } = storeToRefs(funcStore);
 
-const storeFuncDetails = computed(() => funcStore.selectedFuncDetails);
-const editingFunc = ref(_.cloneDeep(storeFuncDetails.value));
+const editingFunc = ref(_.cloneDeep(selectedFuncSummary.value));
 
 function resetEditingFunc() {
-  editingFunc.value = _.cloneDeep(storeFuncDetails.value);
+  editingFunc.value = _.cloneDeep(selectedFuncSummary.value);
 }
 
 // when the func details finish loading, we copy into our local draft
-watch([loadFuncDetailsReqStatus, updateFuncReqStatus], () => {
+watch([updateFuncReqStatus], () => {
   resetEditingFunc();
 });
 
@@ -343,31 +318,30 @@ watch(
 );
 
 const updateFunc = () => {
-  if (
-    !editingFunc.value ||
-    _.isEqual(editingFunc.value, storeFuncDetails.value)
-  )
-    return;
-  funcStore.UPDATE_FUNC(editingFunc.value);
+  if (editingFunc.value) funcStore.UPDATE_FUNC(editingFunc.value);
 };
 
-const isConnectedToOtherAssetTypes = computed(() => {
-  if (editingFunc?.value && editingFunc?.value?.associations) {
-    const associations = editingFunc.value.associations;
-    switch (associations.type) {
-      case "codeGeneration":
-      case "qualification":
-        return (
-          associations.schemaVariantIds.length > 1 ||
-          associations.componentIds.length > 1
-        );
-      case "action":
-        return associations.schemaVariantIds.length > 1;
-      case "attribute":
-        return associations.prototypes.length > 1;
-      default:
-        return false;
-    }
+// THIS FEELS UNNECESSARY NOW
+const isConnectedToOtherAssetTypes = computed<boolean>(() => {
+  if (
+    selectedFuncSummary.value &&
+    selectedFuncSummary.value.bindings.length > 0
+  ) {
+    return selectedFuncSummary.value.bindings
+      .map((b: FuncBinding) => {
+        switch (b.bindingKind) {
+          case FuncBindingKind.Qualification:
+          case FuncBindingKind.CodeGeneration:
+            return !!b.schemaVariantId;
+          case FuncBindingKind.Action:
+            return !!b.schemaVariantId;
+          case FuncBindingKind.Attribute:
+            return !!b.attributePrototypeId;
+          default:
+            return false;
+        }
+      })
+      .some(Boolean);
   }
   return false;
 });
@@ -384,9 +358,10 @@ const execFunc = () => {
 const isDetaching = ref(false);
 const detachFunc = async () => {
   if (detachRef.value && "detachFunc" in detachRef.value) {
-    const associations = await detachRef.value.detachFunc();
+    detachRef.value.detachFunc();
+    // TODO: move all this to WsEvents
     if (assetStore.selectedVariantId)
-      assetStore.LOAD_SCHEMA_VARIANT(assetStore.selectedVariantId); // reloads the fn list
+      assetStore.LOAD_SCHEMA_VARIANT(assetStore.selectedVariantId);
     if (funcStore.selectedFuncId)
       assetStore.removeFuncSelection(funcStore.selectedFuncId);
     if (funcStore.selectedFuncId && assetStore.selectedVariantId)
@@ -395,15 +370,6 @@ const detachFunc = async () => {
         funcStore.selectedFuncId,
       );
     funcStore.selectedFuncId = undefined; // brings you back to the asset detail
-
-    if (associations && editingFunc.value) {
-      isDetaching.value = true;
-      await funcStore.UPDATE_FUNC({
-        ...editingFunc.value,
-        associations,
-      });
-      isDetaching.value = false;
-    }
   }
 };
 
@@ -414,21 +380,26 @@ const deleteFunc = async () => {
 };
 
 const hasAssociations = computed(() => {
-  if (editingFunc?.value) {
-    return editingFunc.value.associations === undefined;
-  }
+  if (selectedFuncSummary.value?.bindings.length === 0) return true;
   return false;
 });
 
 // The parent component can allow the test panel to be enabled, but we need to dynamically enable
 // it based on the func kind.
-const enableTestPanel = computed((): boolean => {
+const enableTestPanel = computed(() => {
   return (
     props.allowTestPanel &&
-    (funcStore.selectedFuncDetails?.associations?.type === "action" ||
-      funcStore.selectedFuncDetails?.associations?.type === "attribute" ||
-      funcStore.selectedFuncDetails?.associations?.type === "codeGeneration" ||
-      funcStore.selectedFuncDetails?.associations?.type === "qualification")
+    selectedFuncSummary.value &&
+    selectedFuncSummary.value.bindings
+      .map((b) => b.bindingKind)
+      .filter((kind) =>
+        [
+          FuncBindingKind.Action,
+          FuncBindingKind.Attribute,
+          FuncBindingKind.CodeGeneration,
+          FuncBindingKind.Qualification,
+        ].includes(kind),
+      ).length > 0
   );
 });
 </script>
diff --git a/app/web/src/components/FuncEditor/FuncEditor.vue b/app/web/src/components/FuncEditor/FuncEditor.vue
index 90122b1bae..95f8cc7e9b 100644
--- a/app/web/src/components/FuncEditor/FuncEditor.vue
+++ b/app/web/src/components/FuncEditor/FuncEditor.vue
@@ -18,12 +18,12 @@
       <CodeEditor
         :id="
           changeSetsStore.headChangeSetId !==
-            changeSetsStore.selectedChangeSetId && selectedFuncDetails
-            ? `func-${selectedFuncDetails.id}`
+            changeSetsStore.selectedChangeSetId && selectedFuncCode
+            ? `func-${selectedFuncCode.funcId}`
             : undefined
         "
         v-model="editingFunc"
-        :typescript="selectedFuncDetails?.types"
+        :typescript="selectedFuncCode?.types"
         @change="updateFuncCode"
         @close="emit('close')"
       />
@@ -52,19 +52,19 @@ const props = defineProps({
 });
 
 const funcStore = useFuncStore();
-const { selectedFuncSummary, selectedFuncDetails } = storeToRefs(funcStore);
+const { selectedFuncSummary, selectedFuncCode } = storeToRefs(funcStore);
 
-const editingFunc = ref<string>(selectedFuncDetails.value?.code ?? "");
+const editingFunc = ref<string>(selectedFuncCode.value?.code ?? "");
 
 const loadFuncDetailsReq = funcStore.getRequestStatus(
-  "FETCH_FUNC",
+  "FETCH_CODE",
   props.funcId,
 );
 
 watch(
-  selectedFuncDetails,
+  selectedFuncCode,
   () => {
-    if (!selectedFuncDetails.value) {
+    if (!selectedFuncCode.value) {
       return;
     }
 
@@ -72,10 +72,10 @@ watch(
     // we will copy the code from each the currently edited func into every func we've edited in
     // the past!
     if (
-      selectedFuncDetails.value.id === props.funcId &&
-      editingFunc.value !== selectedFuncDetails.value.code
+      selectedFuncCode.value.funcId === props.funcId &&
+      editingFunc.value !== selectedFuncCode.value.code
     ) {
-      editingFunc.value = selectedFuncDetails.value.code;
+      editingFunc.value = selectedFuncCode.value.code;
     }
   },
   { immediate: true },
diff --git a/app/web/src/components/FuncEditor/FuncList.vue b/app/web/src/components/FuncEditor/FuncList.vue
index 9778324461..0eff6db50a 100644
--- a/app/web/src/components/FuncEditor/FuncList.vue
+++ b/app/web/src/components/FuncEditor/FuncList.vue
@@ -22,7 +22,7 @@
 
       <SiFuncListItem
         v-for="func in funcsForKind(kind)"
-        :key="func.id"
+        :key="func.funcId"
         :func="func"
         :context="context"
       />
@@ -48,11 +48,11 @@ import { PropType } from "vue";
 import { PillCounter, TreeNode, Icon } from "@si/vue-lib/design-system";
 import { Dictionary } from "async";
 import SiFuncListItem from "@/components/SiFuncListItem.vue";
-import { FuncSummary } from "@/store/func/funcs.store";
 import {
   CUSTOMIZABLE_FUNC_TYPES,
   CustomizableFuncKind,
   customizableFuncKindToFuncKind,
+  FuncSummary,
 } from "@/api/sdf/dal/func";
 
 const props = defineProps({
diff --git a/app/web/src/components/FuncEditor/FuncTest.vue b/app/web/src/components/FuncEditor/FuncTest.vue
index 805a765477..2d2a362322 100644
--- a/app/web/src/components/FuncEditor/FuncTest.vue
+++ b/app/web/src/components/FuncEditor/FuncTest.vue
@@ -7,8 +7,10 @@
         <div
           class="font-bold text-xl text-center overflow-hidden text-ellipsis flex-grow break-words"
         >
-          Test {{ funcStore.selectedFuncDetails?.kind + " " || "" }}Function
-          <span class="italic">"{{ editingFunc?.name }}"</span>
+          Test {{ funcStore.selectedFuncSummary?.kind + " " || "" }}Function
+          <span class="italic"
+            >"{{ funcStore.selectedFuncSummary?.name }}"</span
+          >
         </div>
         <StatusIndicatorIcon
           v-if="runningTest"
@@ -35,7 +37,9 @@
           ref="funcTestSelectorRef"
           :testStatus="testStatus"
           :schemaVariantId="selectedAsset?.schemaVariantId"
-          :isAttributeFunc="isAttributeFunc"
+          :isAttributeFunc="
+            funcStore.selectedFuncSummary?.kind === FuncKind.Attribute
+          "
           :readyToTest="readyToTest"
           @startTest="startTest"
           @loadInput="loadInput"
@@ -227,7 +231,7 @@ import { computed, ref } from "vue";
 import { useFuncStore } from "@/store/func/funcs.store";
 import { useAssetStore } from "@/store/asset.store";
 import { useComponentsStore } from "@/store/components.store";
-import { FuncKind } from "@/api/sdf/dal/func";
+import { FuncKind, LeafInputLocation } from "@/api/sdf/dal/func";
 import { useFuncRunsStore } from "@/store/func_runs.store";
 import FuncTestSelector from "./FuncTestSelector.vue";
 import CodeViewer from "../CodeViewer.vue";
@@ -244,15 +248,9 @@ const additionalOutputInfoModalRef = ref();
 const funcTestSelectorRef = ref<InstanceType<typeof FuncTestSelector>>();
 
 const selectedAsset = computed(() => assetStore.selectedSchemaVariant);
-const editingFuncDetails = computed(() => funcStore.selectedFuncDetails);
-const editingFunc = ref(_.cloneDeep(editingFuncDetails.value));
 
-const isAttributeFunc = computed(() => {
-  if (!funcStore.selectedFuncId) return false;
-  return funcStore.selectedFuncDetails?.associations?.type === "attribute";
-});
 const enableTestTabGroup = computed((): boolean => {
-  if (isAttributeFunc.value) {
+  if (funcStore.selectedFuncSummary?.kind === FuncKind.Attribute) {
     if (
       funcTestSelectorRef.value?.selectedComponentId &&
       funcTestSelectorRef.value?.selectedPrototypeId
@@ -279,7 +277,7 @@ const runningTest = ref(false);
 const dryRunConfig = computed(() => {
   // TODO(Wendy) - which function variants allow for a choice of dry run? which are always dry and which are always wet?
   // Note(Paulo): We only support dry run when testing functions
-  if (funcStore.selectedFuncDetails?.kind === FuncKind.Attribute) {
+  if (funcStore.selectedFuncSummary?.kind === FuncKind.Attribute) {
     return "dry";
   } else {
     // return "wet";
@@ -363,28 +361,26 @@ const prepareTest = async () => {
 
   resetTestData();
 
-  const selectedFunc = funcStore.selectedFuncDetails;
-
-  if (selectedFunc?.associations?.type === "attribute") {
+  if (funcStore.selectedFuncSummary?.kind === FuncKind.Attribute) {
     if (!funcTestSelectorRef.value.selectedPrototypeId) {
       throw new Error(
         "cannot prepare test for attribute func without a selected prototype",
       );
     }
 
-    const prototype = _.find(
-      selectedFunc.associations.prototypes,
-      (p) => p.id === funcTestSelectorRef.value?.selectedPrototypeId,
-    );
-    if (!prototype) {
-      throw new Error(
-        "could not find prototype for selected prototype id when preparing test",
-      );
-    }
+    const propId = funcTestSelectorRef.value.selectedPrototypeId.startsWith(
+      "p_",
+    )
+      ? funcTestSelectorRef.value.selectedPrototypeId.replace("p_", "")
+      : undefined;
+    const outputSocketId =
+      funcTestSelectorRef.value.selectedPrototypeId.startsWith("s_")
+        ? funcTestSelectorRef.value.selectedPrototypeId.replace("s_", "")
+        : undefined;
 
     const res = await funcStore.FETCH_PROTOTYPE_ARGUMENTS(
-      prototype.propId,
-      prototype.outputSocketId,
+      propId,
+      outputSocketId,
     );
     if (!res.result.success) {
       throw new Error(
@@ -399,8 +395,8 @@ const prepareTest = async () => {
     testInputCode.value = JSON.stringify(properties, null, 2);
     testInputProperties.value = properties;
   } else if (
-    selectedFunc?.associations?.type === "codeGeneration" ||
-    selectedFunc?.associations?.type === "qualification"
+    funcStore.selectedFuncSummary?.kind === FuncKind.CodeGeneration ||
+    funcStore.selectedFuncSummary?.kind === FuncKind.Qualification
   ) {
     const res = await componentsStore.FETCH_COMPONENT_JSON(
       funcTestSelectorRef.value.selectedComponentId,
@@ -432,12 +428,35 @@ const prepareTest = async () => {
     };
 
     const properties: Record<string, unknown> = {};
-    for (const input of selectedFunc.associations.inputs) {
-      if (!props) break;
-
-      const key = toSnakeCase(`${input}`);
-      properties[key] = props[key];
-    }
+    let selectedInputs = [] as LeafInputLocation[];
+
+    if (funcStore.selectedFuncSummary?.kind === FuncKind.CodeGeneration)
+      selectedInputs =
+        funcStore.codegenBindings[funcStore.selectedFuncId]?.find((b) => {
+          const schemaVariantId =
+            componentsStore.componentsById[
+              funcTestSelectorRef.value?.selectedComponentId || ""
+            ]?.schemaVariantId;
+          if (schemaVariantId) return b.schemaVariantId === schemaVariantId;
+          return false;
+        })?.inputs || [];
+
+    if (funcStore.selectedFuncSummary?.kind === FuncKind.Qualification)
+      selectedInputs =
+        funcStore.qualificationBindings[funcStore.selectedFuncId]?.find((b) => {
+          const schemaVariantId =
+            componentsStore.componentsById[
+              funcTestSelectorRef.value?.selectedComponentId || ""
+            ]?.schemaVariantId;
+          if (schemaVariantId) return b.schemaVariantId === schemaVariantId;
+          return false;
+        })?.inputs || [];
+
+    if (props)
+      for (const input of selectedInputs) {
+        const key = toSnakeCase(`${input}`);
+        properties[key] = props[key];
+      }
 
     testInputCode.value = JSON.stringify(properties, null, 2);
     testInputProperties.value = properties;
@@ -451,7 +470,7 @@ const prepareTest = async () => {
 
 const startTest = async () => {
   if (
-    !funcStore.selectedFuncDetails ||
+    !funcStore.selectedFuncCode ||
     !funcTestSelectorRef.value?.selectedComponentId ||
     !readyToTest.value
   )
@@ -468,9 +487,9 @@ const startTest = async () => {
   const args = testInputProperties.value;
 
   const response = await funcStore.TEST_EXECUTE({
-    id: funcStore.selectedFuncDetails.id,
+    funcId: funcStore.selectedFuncCode.funcId,
     args,
-    code: funcStore.selectedFuncDetails.code,
+    code: funcStore.selectedFuncCode.code,
     componentId: funcTestSelectorRef.value?.selectedComponentId,
   });
 
diff --git a/app/web/src/components/FuncEditor/FuncTestSelector.vue b/app/web/src/components/FuncEditor/FuncTestSelector.vue
index d7823293df..9250f85149 100644
--- a/app/web/src/components/FuncEditor/FuncTestSelector.vue
+++ b/app/web/src/components/FuncEditor/FuncTestSelector.vue
@@ -38,7 +38,9 @@ import { VButton, VormInput } from "@si/vue-lib/design-system";
 import { PropType, computed, ref } from "vue";
 import { useComponentsStore } from "@/store/components.store";
 import { useFuncStore } from "@/store/func/funcs.store";
-import { AttributePrototypeBag } from "@/store/func/types";
+import { FuncKind } from "@/api/sdf/dal/func";
+import { outputSocketsAndPropsFor } from "@/api/sdf/dal/schema";
+import { Option } from "@/components/SelectMenu.vue";
 import { TestStatus } from "./FuncTest.vue";
 
 const componentsStore = useComponentsStore();
@@ -72,78 +74,48 @@ const disableTestButton = computed(
     (props.isAttributeFunc && !selectedPrototypeId.value),
 );
 
-const prototypeIsForSelectedComponent = (
-  prototype: AttributePrototypeBag,
-): boolean => {
-  // First, we need to ensure the component and its asset have been selected . If not, we need to bail.
-  if (!selectedComponentId.value) {
-    return false;
-  }
-
-  // Default to checking if the prototype belongs to the component first. If it doesn't, we need to check
-  // if it belongs its schema variant. If the prototype belongs to neither, it has been orphaned and we need to
-  // error (this should not be possible, but we still want to check).
-  if (prototype.componentId) {
-    return prototype.componentId === selectedComponentId.value;
-  } else if (prototype.schemaVariantId) {
-    return prototype.schemaVariantId === props.schemaVariantId;
-  } else {
-    throw new Error(
-      "prototype has been orphaned: it neither belongs to a component nor a schema variant",
-    );
-  }
-};
-
 // Only for attribute funcs, assemble prototypes that belong to the selected component.
-const prototypeAttributeOptions = computed(
-  (): {
-    label: string;
-    value: string;
-  }[] => {
-    const options = [];
-
-    // Despite the fact that we can compile prototype options for _all_ components, we should wait until
-    // the user selects a _single_ component.
-    if (!funcStore.selectedFuncId || !selectedComponentId.value) return [];
-    const selectedFunc = funcStore.selectedFuncDetails;
+const prototypeAttributeOptions = computed(() => {
+  let options: Option[] = [];
 
-    if (selectedFunc?.associations?.type === "attribute") {
-      const attributeAssociations = selectedFunc.associations;
+  // Despite the fact that we can compile prototype options for _all_ components, we should wait until
+  // the user selects a _single_ component.
+  if (!funcStore.selectedFuncId || !selectedComponentId.value) return [];
 
-      for (const prototype of attributeAssociations.prototypes) {
-        if (prototypeIsForSelectedComponent(prototype)) {
-          // Once we know the prototype belongs to either the selected component or its schema variant,
-          // we assemble the option based on what output location the prototype is bound to. If it is
-          // bound to nowhere, we need to error (this should not be possible, but we still want to check).
-          if (prototype.propId) {
-            options.push({
-              label:
-                funcStore.propIdToSourceName(prototype.propId) ??
-                `Attribute: ${prototype.propId}`,
-              value: prototype.id,
-            });
-          } else if (prototype.outputSocketId) {
-            options.push({
-              label:
-                funcStore.outputSocketIdToSourceName(
-                  prototype.outputSocketId,
-                ) ?? `Output Socket: ${prototype.outputSocketId}`,
-              value: prototype.id,
-            });
-          } else {
-            throw new Error(
-              "prototype to test is not bound to an output location",
-            );
-          }
+  if (funcStore.selectedFuncSummary?.kind === FuncKind.Attribute) {
+    funcStore.attributeBindings[funcStore.selectedFuncSummary.funcId]?.forEach(
+      (binding) => {
+        let schemaVariant;
+        if (
+          binding.schemaVariantId &&
+          binding.schemaVariantId === props.schemaVariantId
+        )
+          schemaVariant =
+            componentsStore.schemaVariantsById[binding.schemaVariantId];
+        if (
+          binding.componentId &&
+          binding.componentId === selectedComponentId.value
+        ) {
+          const schemaVariantId =
+            componentsStore.componentsById[binding.componentId]
+              ?.schemaVariantId;
+          if (schemaVariantId)
+            schemaVariant = componentsStore.schemaVariantsById[schemaVariantId];
         }
-      }
-      return options;
-    } else {
-      // If the selected func is not an attribute func, there are no options to assemble.
-      return [];
-    }
-  },
-);
+        if (schemaVariant) {
+          const { socketOptions, propOptions } =
+            outputSocketsAndPropsFor(schemaVariant);
+          options = [...socketOptions, ...propOptions];
+        }
+      },
+    );
+
+    return options;
+  } else {
+    // If the selected func is not an attribute func, there are no options to assemble.
+    return [];
+  }
+});
 
 // We need the user to select a prototype after selecting a component if its an attribute func.
 const loadInputIfNotAttributeFunc = () => {
diff --git a/app/web/src/components/FuncEditor/LeafInputs.vue b/app/web/src/components/FuncEditor/LeafInputs.vue
index 061ce9fee6..f10f4fa49a 100644
--- a/app/web/src/components/FuncEditor/LeafInputs.vue
+++ b/app/web/src/components/FuncEditor/LeafInputs.vue
@@ -34,7 +34,7 @@
 <script lang="ts" setup>
 import { ref, watch } from "vue";
 import { VormInput } from "@si/vue-lib/design-system";
-import { LeafInputLocation } from "@/store/func/types";
+import { LeafInputLocation } from "@/api/sdf/dal/func";
 
 const props = defineProps<{
   modelValue: LeafInputLocation[];
diff --git a/app/web/src/components/FuncEditor/QualificationDetails.vue b/app/web/src/components/FuncEditor/QualificationDetails.vue
index f4ff5c2730..e1a7c96f98 100644
--- a/app/web/src/components/FuncEditor/QualificationDetails.vue
+++ b/app/web/src/components/FuncEditor/QualificationDetails.vue
@@ -1,108 +1,43 @@
 <template>
   <div class="p-3 flex flex-col gap-xs">
-    <template v-if="!schemaVariantId">
-      <h1 class="text-neutral-400 dark:text-neutral-300 text-sm">
-        Run this qualification on the selected asset and assets of type below.
-      </h1>
-      <h2 class="pt-2 text-neutral-700 type-bold-sm dark:text-neutral-50">
-        Run on Asset:
-      </h2>
-      <RunOnSelector
-        v-model="selectedComponents"
-        thingLabel="asset"
-        :options="componentOptions"
-        :disabled="disabled"
-        @change="updateAssociations"
-      />
-      <h2 class="pt-4 text-neutral-700 type-bold-sm dark:text-neutral-50">
-        Run on Assets of Type:
-      </h2>
-      <RunOnSelector
-        v-model="selectedVariants"
-        thingLabel="assets of type"
-        :options="schemaVariantOptions"
-        :disabled="disabled"
-        @change="updateAssociations"
-      />
-    </template>
-    <LeafInputs v-model="inputs" @change="updateAssociations" />
+    <LeafInputs v-model="inputs" @change="update" />
   </div>
 </template>
 
 <script lang="ts" setup>
-import { ref, watch, toRef } from "vue";
-import { storeToRefs } from "pinia";
-import { Option } from "@/components/SelectMenu.vue";
-import {
-  FuncAssociations,
-  QualificationAssociations,
-} from "@/store/func/types";
-import { toOptionValues } from "@/components/FuncEditor/utils";
+import { ref, computed } from "vue";
+import * as _ from "lodash-es";
 import { useFuncStore } from "@/store/func/funcs.store";
-import RunOnSelector from "./RunOnSelector.vue";
 import LeafInputs from "./LeafInputs.vue";
 
 const funcStore = useFuncStore();
-const { componentOptions, schemaVariantOptions } = storeToRefs(funcStore);
 
 const props = defineProps<{
-  modelValue: QualificationAssociations;
-  schemaVariantId?: string;
+  funcId: string;
+  schemaVariantId: string;
   disabled?: boolean;
 }>();
 
-const modelValue = toRef(props, "modelValue");
-
-const selectedVariants = ref<Option[]>(
-  toOptionValues(schemaVariantOptions.value, modelValue.value.schemaVariantIds),
-);
-const selectedComponents = ref<Option[]>(
-  toOptionValues(componentOptions.value, modelValue.value.componentIds),
-);
-
-const inputs = ref(modelValue.value.inputs);
-
-const emit = defineEmits<{
-  (e: "update:modelValue", v: QualificationAssociations): void;
-  (e: "change", v: QualificationAssociations): void;
-}>();
-
-watch(
-  [modelValue, schemaVariantOptions, componentOptions],
-  ([mv, svOpts, componentOpts]) => {
-    selectedVariants.value = toOptionValues(svOpts, mv.schemaVariantIds);
-    selectedComponents.value = toOptionValues(componentOpts, mv.componentIds);
-    inputs.value = mv.inputs;
-  },
-  { immediate: true },
-);
-
-const getUpdatedAssocations = (
-  schemaVariantIds: string[],
-): QualificationAssociations => ({
-  componentIds: selectedComponents.value.map(({ value }) => value as string),
-  schemaVariantIds,
-  inputs: inputs.value,
-  type: "qualification",
+const binding = computed(() => {
+  const bindings = funcStore.qualificationBindings[props.funcId];
+  const binding = bindings
+    ?.filter((b) => b.schemaVariantId === props.schemaVariantId)
+    .pop();
+  return binding;
 });
 
-const updateAssociations = () => {
-  const associations = getUpdatedAssocations(
-    selectedVariants.value.map(({ value }) => value as string),
-  );
-  emit("update:modelValue", associations);
-  emit("change", associations);
-};
+const inputs = ref(_.clone(binding.value?.inputs) || []);
 
-const detachFunc = (): FuncAssociations | undefined => {
-  if (props.schemaVariantId) {
-    return getUpdatedAssocations(
-      selectedVariants.value
-        .map(({ value }) => value as string)
-        .filter((schemaVariantId) => schemaVariantId !== props.schemaVariantId),
-    );
+const update = () => {
+  if (binding.value) {
+    binding.value.inputs = _.clone(inputs.value);
+    funcStore.UPDATE_BINDING(props.funcId, [binding.value]);
   }
 };
 
+const detachFunc = () => {
+  if (binding.value) funcStore.DELETE_BINDING(props.funcId, [binding.value]);
+};
+
 defineExpose({ detachFunc });
 </script>
diff --git a/app/web/src/components/SelectMenu.vue b/app/web/src/components/SelectMenu.vue
index a60a5b12b2..23721f5319 100644
--- a/app/web/src/components/SelectMenu.vue
+++ b/app/web/src/components/SelectMenu.vue
@@ -85,6 +85,10 @@ export interface Option {
   value: string | number | object;
 }
 
+export interface StringOption extends Option {
+  value: string;
+}
+
 const emit = defineEmits(["update:modelValue", "change"]);
 
 const props = defineProps<{
diff --git a/app/web/src/components/SiFuncListItem.vue b/app/web/src/components/SiFuncListItem.vue
index e97e6d3ad2..b51dc40e1a 100644
--- a/app/web/src/components/SiFuncListItem.vue
+++ b/app/web/src/components/SiFuncListItem.vue
@@ -8,7 +8,7 @@
       )
     "
     noIndentationOrLeftBorder
-    :isSelected="funcStore.selectedFuncId === func.id"
+    :isSelected="funcStore.selectedFuncId === func.funcId"
     showSelection
     @mousedown.left.stop="onClick"
   >
@@ -30,7 +30,8 @@
 <script setup lang="ts">
 import { TreeNode } from "@si/vue-lib/design-system";
 import clsx from "clsx";
-import { FuncSummary, useFuncStore } from "@/store/func/funcs.store";
+import { useFuncStore } from "@/store/func/funcs.store";
+import { FuncSummary } from "@/api/sdf/dal/func";
 import { useAssetStore } from "@/store/asset.store";
 import { trackEvent } from "@/utils/tracking";
 
@@ -45,13 +46,13 @@ const funcStore = useFuncStore();
 
 const trackFunctionSelected = () => {
   trackEvent("function_selected_for_edit", {
-    func_id: props.func.id,
+    func_id: props.func.funcId,
     func_name: props.func.name,
   });
 };
 
 const onClick = () => {
   trackFunctionSelected();
-  assetStore.addFuncSelection(props.func.id);
+  assetStore.addFuncSelection(props.func.funcId);
 };
 </script>
diff --git a/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue b/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue
index f523ec94a0..2770d016eb 100644
--- a/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue
+++ b/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue
@@ -44,9 +44,12 @@
       />
       <template v-if="assetStore.selectedVariantId">
         <FuncDetails
-          v-if="funcStore.selectedFuncId"
+          v-if="
+            funcStore.selectedFuncId &&
+            assetStore.selectedSchemaVariant?.schemaVariantId
+          "
           :funcId="funcStore.selectedFuncId"
-          :schemaVariantId="assetStore.selectedSchemaVariant?.schemaVariantId"
+          :schemaVariantId="assetStore.selectedSchemaVariant.schemaVariantId"
           singleModelScreen
           allowTestPanel
           @expand-panel="rightResizablePanelRef?.maximize()"
diff --git a/app/web/src/store/actions.store.ts b/app/web/src/store/actions.store.ts
index 06f3956737..37793d1434 100644
--- a/app/web/src/store/actions.store.ts
+++ b/app/web/src/store/actions.store.ts
@@ -8,6 +8,14 @@ import { DefaultMap } from "@/utils/defaultmap";
 import { ChangeSetId } from "@/api/sdf/dal/change_set";
 import { ComponentId } from "@/api/sdf/dal/component";
 import { omit } from "@/utils/omit";
+import {
+  ActionId,
+  ActionKind,
+  ActionPrototype,
+  ActionPrototypeId,
+  ActionState,
+  ActionResultState,
+} from "@/api/sdf/dal/action";
 import { useChangeSetsStore } from "./change_sets.store";
 import { useRealtimeStore } from "./realtime/realtime.store";
 
@@ -42,12 +50,6 @@ export type DeprecatedActionBatch = {
   finishedAt: string | null;
 };
 
-export interface ActionPrototype {
-  id: ActionPrototypeId;
-  name: string;
-  displayName: string;
-}
-
 export type ComponentAndAction = {
   actionPrototypeId: ActionPrototypeId;
   actionInstanceId?: ActionId;
@@ -55,22 +57,6 @@ export type ComponentAndAction = {
   actor?: string;
 } & Omit<ActionPrototype, "id">;
 
-export enum ActionState {
-  Dispatched = "Dispatched",
-  Failed = "Failed",
-  OnHold = "OnHold",
-  Queued = "Queued",
-  Running = "Running",
-}
-
-export enum ActionKind {
-  Create = "Create",
-  Destroy = "Destroy",
-  Refresh = "Refresh",
-  Manual = "Manual",
-  Update = "Update",
-}
-
 export interface ActionView {
   id: ActionId;
   actor?: string; // TODO i dont see this on the backend
@@ -90,12 +76,6 @@ export interface ActionProposedView extends ActionView {
   holdStatusInfluencedBy: ActionId[];
 }
 
-export enum ActionResultState {
-  Success = "Success",
-  Failure = "Failure",
-  Unknown = "Unknown",
-}
-
 export interface ActionHistoryView extends ActionView {
   funcRunId: FuncRunId;
   result: ActionResultState;
@@ -117,8 +97,6 @@ export interface ChangeSetDetail {
 
 // STUFF FOR BOTH ACTIONS V1 AND V2
 
-export type ActionPrototypeId = string;
-export type ActionId = string;
 export type FuncRunId = string;
 
 // END STUFF
diff --git a/app/web/src/store/asset.store.ts b/app/web/src/store/asset.store.ts
index df053720cc..f641766f62 100644
--- a/app/web/src/store/asset.store.ts
+++ b/app/web/src/store/asset.store.ts
@@ -10,7 +10,7 @@ import keyedDebouncer from "@/utils/keyedDebouncer";
 import router from "@/router";
 import { PropKind } from "@/api/sdf/dal/prop";
 import { nonNullable } from "@/utils/typescriptLinter";
-import { FuncWithDetails, useFuncStore } from "./func/funcs.store";
+import { useFuncStore } from "./func/funcs.store";
 import { useChangeSetsStore } from "./change_sets.store";
 import { useRealtimeStore } from "./realtime/realtime.store";
 import handleStoreError from "./errors";
@@ -137,11 +137,6 @@ export const useAssetStore = () => {
           if (state.selectedFuncs.length === 1) return state.selectedFuncs[0];
           else return undefined;
         },
-        selectedFunc(): FuncWithDetails | undefined {
-          if (this.selectedFuncId)
-            return funcsStore.funcDetailsById[this.selectedFuncId];
-          else return undefined;
-        },
       },
       actions: {
         addSchemaVariantSelection(id: SchemaVariantId) {
@@ -152,7 +147,7 @@ export const useAssetStore = () => {
             this.selectedFuncs = [];
           }
         },
-        setSchemaVariantSelection(id: SchemaVariantId) {
+        setSchemaVariantSelection(id: SchemaVariantId, forceCode?: boolean) {
           if (
             this.selectedSchemaVariants.length === 1 &&
             this.selectedSchemaVariants[0] === id
@@ -164,15 +159,13 @@ export const useAssetStore = () => {
           }
           this.selectedSchemaVariants = [id];
           this.syncSelectionIntoUrl();
-          if (this.variantFromListById[id]) {
-            this.LOAD_SCHEMA_VARIANT(id);
-          }
+          this.LOAD_SCHEMA_VARIANT(id, forceCode);
           // no last selected func
           funcsStore.selectedFuncId = undefined;
         },
         async addFuncSelection(id: FuncId) {
           if (!this.selectedFuncs.includes(id)) this.selectedFuncs.push(id);
-          await funcsStore.FETCH_FUNC(id);
+          await funcsStore.FETCH_CODE(id);
           if (this.selectedSchemaVariant)
             this.openFunc(this.selectedSchemaVariant?.schemaVariantId, id);
           funcsStore.selectedFuncId = id;
@@ -223,7 +216,7 @@ export const useAssetStore = () => {
               } else if (id.startsWith("f_")) {
                 id = id.substring(2);
                 this.selectedFuncs.push(id);
-                promises.push(funcsStore.FETCH_FUNC(id));
+                promises.push(funcsStore.FETCH_CODE(id));
                 fnIds.push(id);
               }
             });
@@ -399,13 +392,18 @@ export const useAssetStore = () => {
           });
         },
 
-        async LOAD_SCHEMA_VARIANT(schemaVariantId: SchemaVariantId) {
-          // when we load a variant, load all its code ahead of time before a user selects a func
+        async LOAD_SCHEMA_VARIANT(
+          schemaVariantId: SchemaVariantId,
+          forceCode?: boolean,
+        ) {
           const variant = this.variantFromListById[schemaVariantId];
           if (variant) {
-            await funcsStore.FETCH_FUNC(variant.assetFuncId);
+            // if we clicked on the item in the list, or we don't have the code yet, load it
+            // otherwise don't load it——we may be overwriting something
+            if (!funcsStore.funcCodeById[variant.assetFuncId] || forceCode)
+              await funcsStore.FETCH_CODE(variant.assetFuncId);
 
-            const code = funcsStore.funcDetailsById[variant.assetFuncId]?.code;
+            const code = funcsStore.funcCodeById[variant.assetFuncId]?.code;
 
             if (code) {
               this.editingFuncLatestCode[schemaVariantId] = code;
@@ -548,8 +546,19 @@ export const useAssetStore = () => {
                 this.LOAD_SCHEMA_VARIANT(this.selectedVariantId);
                 await useComponentsStore().FETCH_AVAILABLE_SCHEMAS();
               }
-
-              await funcsStore.FETCH_INPUT_SOURCE_LIST(data.newSchemaVariantId);
+            },
+          },
+          {
+            eventType: "SchemaVariantUpdated",
+            callback: (variant, metadata) => {
+              if (metadata.change_set_id !== changeSetId) return;
+              const v = variant as SchemaVariantListEntry;
+              v.canContribute = false;
+              v.canUpdate = false;
+              const savedAssetIdx = this.variantList.findIndex(
+                (a) => a.schemaVariantId === variant.schemaVariantId,
+              );
+              this.variantList.splice(savedAssetIdx, 1, v);
             },
           },
           {
diff --git a/app/web/src/store/components.store.ts b/app/web/src/store/components.store.ts
index 930fb99380..8601b3c6de 100644
--- a/app/web/src/store/components.store.ts
+++ b/app/web/src/store/components.store.ts
@@ -443,6 +443,12 @@ export const useComponentsStore = (forceChangeSetId?: ChangeSetId) => {
           selectedComponentResource(): Resource | undefined {
             return this.componentResourceById[this.selectedComponentId || 0];
           },
+          schemaVariantOptions: (state): { label: string; value: string }[] => {
+            return Object.values(state.schemaVariantsById).map((sv) => ({
+              label: sv.displayName || sv.schemaName,
+              value: sv.schemaVariantId,
+            }));
+          },
 
           diagramNodes(): DiagramNodeDef[] {
             const qualificationsStore = useQualificationsStore();
@@ -1131,28 +1137,28 @@ export const useComponentsStore = (forceChangeSetId?: ChangeSetId) => {
             });
           },
 
-          async FETCH_COMPONENT_DIFF(componentId: ComponentId) {
-            return new ApiRequest<{ componentDiff: ComponentDiff }>({
-              url: "component/get_diff",
+          async FETCH_COMPONENT_JSON(componentId: ComponentId) {
+            return new ApiRequest<{ json: unknown }>({
+              url: "component/json",
               keyRequestStatusBy: componentId,
               params: {
                 componentId,
                 ...visibilityParams,
               },
-              onSuccess: (response) => {
-                this.componentDiffsById[componentId] = response.componentDiff;
-              },
             });
           },
 
-          async FETCH_COMPONENT_JSON(componentId: ComponentId) {
-            return new ApiRequest<{ json: unknown }>({
-              url: "component/json",
+          async FETCH_COMPONENT_DIFF(componentId: ComponentId) {
+            return new ApiRequest<{ componentDiff: ComponentDiff }>({
+              url: "component/get_diff",
               keyRequestStatusBy: componentId,
               params: {
                 componentId,
                 ...visibilityParams,
               },
+              onSuccess: (response) => {
+                this.componentDiffsById[componentId] = response.componentDiff;
+              },
             });
           },
 
diff --git a/app/web/src/store/func/funcs.store.ts b/app/web/src/store/func/funcs.store.ts
index 69c1fa81f5..72357768a8 100644
--- a/app/web/src/store/func/funcs.store.ts
+++ b/app/web/src/store/func/funcs.store.ts
@@ -6,10 +6,18 @@ import storage from "local-storage-fallback"; // drop-in storage polyfill which
 import { Visibility } from "@/api/sdf/dal/visibility";
 import {
   FuncArgument,
-  FuncArgumentKind,
-  FuncKind,
   FuncId,
   FuncArgumentId,
+  FuncSummary,
+  FuncCode,
+  FuncBinding,
+  FuncBindingKind,
+  FuncKind,
+  Action,
+  Attribute,
+  CodeGeneration,
+  Authentication,
+  Qualification,
 } from "@/api/sdf/dal/func";
 
 import { nilId } from "@/utils/nilId";
@@ -17,40 +25,12 @@ import { trackEvent } from "@/utils/tracking";
 import keyedDebouncer from "@/utils/keyedDebouncer";
 import { useWorkspacesStore } from "@/store/workspaces.store";
 import { useAssetStore } from "@/store/asset.store";
-import { PropId } from "@/api/sdf/dal/prop";
-import { SchemaVariantId, OutputSocketId } from "@/api/sdf/dal/schema";
 import { useChangeSetsStore } from "../change_sets.store";
 import { useRealtimeStore } from "../realtime/realtime.store";
 import { useComponentsStore } from "../components.store";
 
-import {
-  AttributePrototypeBag,
-  AttributePrototypeArgumentBag,
-  CreateFuncOptions,
-  FuncAssociations,
-  InputSocketView,
-  InputSourceProp,
-  OutputLocation,
-  OutputSocketView,
-} from "./types";
-
 import { FuncRunId } from "../func_runs.store";
 
-export type FuncSummary = {
-  id: string;
-  kind: FuncKind;
-  name: string;
-  displayName?: string;
-  description?: string;
-  isBuiltin: boolean;
-};
-
-export type FuncWithDetails = FuncSummary & {
-  code: string;
-  types: string;
-  associations?: FuncAssociations;
-};
-
 type FuncExecutionState =
   | "Create"
   | "Dispatch"
@@ -69,26 +49,12 @@ export type FuncExecutionLog = {
   functionFailure?: any; // FunctionResultFailure
 };
 
-export interface SaveFuncResponse {
-  types: string;
-  associations?: FuncAssociations;
-}
-
 export interface DeleteFuncResponse {
   success: boolean;
 }
 
-export interface OutputLocationOption {
-  label: string;
-  value: OutputLocation;
-}
-
 const LOCAL_STORAGE_FUNC_IDS_KEY = "si-open-func-ids";
 
-export type InputSourceProps = { [key: string]: InputSourceProp[] };
-export type InputSocketViews = { [key: string]: InputSocketView[] };
-export type OutputSocketViews = { [key: string]: OutputSocketView[] };
-
 export const useFuncStore = () => {
   const componentsStore = useComponentsStore();
   const changeSetsStore = useChangeSetsStore();
@@ -106,251 +72,142 @@ export const useFuncStore = () => {
 
   let funcSaveDebouncer: ReturnType<typeof keyedDebouncer> | undefined;
 
+  const processBindings = (func: FuncSummary) => {
+    const actionBindings = [] as Action[];
+    const attributeBindings = [] as Attribute[];
+    const authenticationBindings = [] as Authentication[];
+    const codegenBindings = [] as CodeGeneration[];
+    const qualificationBindings = [] as Qualification[];
+
+    func.bindings.forEach((binding) => {
+      switch (binding.bindingKind) {
+        case FuncBindingKind.Action:
+          actionBindings.push(binding as Action);
+          break;
+        case FuncBindingKind.Attribute:
+          attributeBindings.push(binding as Attribute);
+          break;
+        case FuncBindingKind.Authentication:
+          authenticationBindings.push(binding as Authentication);
+          break;
+        case FuncBindingKind.CodeGeneration:
+          codegenBindings.push(binding as CodeGeneration);
+          break;
+        case FuncBindingKind.Qualification:
+          qualificationBindings.push(binding as Qualification);
+          break;
+        default:
+          throw new Error(`Unexpected FuncBinding ${JSON.stringify(binding)}`);
+      }
+    });
+
+    return {
+      actionBindings,
+      attributeBindings,
+      authenticationBindings,
+      codegenBindings,
+      qualificationBindings,
+    };
+  };
+
+  const API_PREFIX = `v2/workspaces/${workspaceId}/change-sets/${selectedChangeSetId}/funcs`;
+
   return addStoreHooks(
     defineStore(`ws${workspaceId || "NONE"}/cs${selectedChangeSetId}/funcs`, {
       state: () => ({
         // this powers the list
         funcsById: {} as Record<FuncId, FuncSummary>,
-        funcArgumentsById: {} as Record<FuncArgumentId, FuncArgument>,
-        funcArgumentsByFuncId: {} as Record<FuncId, FuncArgument[]>,
         // this is the code
-        funcDetailsById: {} as Record<FuncId, FuncWithDetails>,
-        // map from schema variant ids to the input sources
-        inputSourceSockets: {} as InputSocketViews,
-        inputSourceProps: {} as InputSourceProps,
-        outputSockets: {} as OutputSocketViews,
+        funcCodeById: {} as Record<FuncId, FuncCode>,
+        // bindings
+        actionBindings: {} as Record<FuncId, Action[]>,
+        attributeBindings: {} as Record<FuncId, Attribute[]>,
+        authenticationBindings: {} as Record<FuncId, Authentication[]>,
+        codegenBindings: {} as Record<FuncId, CodeGeneration[]>,
+        qualificationBindings: {} as Record<FuncId, Qualification[]>,
+        // open editor tabs, this is duplicated in asset store
         openFuncIds: [] as FuncId[],
-        lastFuncExecutionLogByFuncId: {} as Record<FuncId, FuncExecutionLog>,
         // represents the last, or "focused" func clicked on/open by the editor
         selectedFuncId: undefined as FuncId | undefined,
+        editingFuncLatestCode: {} as Record<FuncId, string>,
       }),
       getters: {
         selectedFuncSummary(state): FuncSummary | undefined {
           return state.funcsById[this.selectedFuncId || ""];
         },
-        selectedFuncDetails(state): FuncWithDetails | undefined {
-          return state.funcDetailsById[this.selectedFuncId || ""];
-        },
-        funcArguments(state): FuncArgument[] | undefined {
-          return state.selectedFuncId
-            ? state.funcArgumentsByFuncId[state.selectedFuncId]
-            : undefined;
+        selectedFuncCode(state): FuncCode | undefined {
+          return state.funcCodeById[this.selectedFuncId || ""];
         },
 
         nameForSchemaVariantId: (_state) => (schemaVariantId: string) =>
           componentsStore.schemaVariantsById[schemaVariantId]?.schemaName,
 
-        funcById: (state) => (funcId: FuncId) => state.funcDetailsById[funcId],
-
         funcList: (state) => _.values(state.funcsById),
-
-        allProps: (state) =>
-          _.reduce(
-            state.inputSourceProps,
-            (acc, props) => [...acc, ...props],
-            [] as InputSourceProp[],
-          ),
-
-        propsForId(): Record<PropId, InputSourceProp> {
-          return _.keyBy(this.allProps, (s) => s.propId);
-        },
-
-        inputSocketForId:
-          (state) =>
-          (inputSocketId: string): InputSocketView | undefined => {
-            for (const sockets of Object.values(state.inputSourceSockets)) {
-              const inputSourceSocket = sockets.find(
-                (socket) => socket.inputSocketId === inputSocketId,
-              );
-              if (inputSourceSocket) {
-                return inputSourceSocket;
-              }
-            }
-            return undefined;
-          },
-
-        allOutputSockets: (state) => {
-          return _.reduce(
-            state.outputSockets,
-            (acc, sockets) => [...acc, ...sockets],
-            [] as OutputSocketView[],
-          );
-        },
-
-        outputSocketsForId(): Record<OutputSocketId, OutputSocketView> {
-          return _.keyBy(this.allOutputSockets, (s) => s.outputSocketId);
-        },
-
-        schemaVariantIdForPrototypeTargetId(): Record<
-          OutputSocketId | PropId,
-          SchemaVariantId
-        > {
-          const propsBySvId = _.mapValues(
-            this.propsForId,
-            (p) => p.schemaVariantId,
-          );
-          const outputSocketBySvId = _.mapValues(
-            this.outputSocketsForId,
-            (s) => s.schemaVariantId,
-          );
-
-          return _.merge({}, propsBySvId, outputSocketBySvId);
-        },
-
-        // Filter props by schema variant
-        propsAsOptionsForSchemaVariant: (state) => (schemaVariantId: string) =>
-          (schemaVariantId === nilId()
-            ? _.flatten(Object.values(state.inputSourceProps))
-            : state.inputSourceProps[schemaVariantId]
-          )?.map((prop) => ({
-            label: prop.path,
-            value: prop.propId,
-          })) ?? [],
-
-        schemaVariantOptions() {
-          return componentsStore.schemaVariants.map((sv) => ({
-            label: sv.schemaName,
-            value: sv.schemaVariantId,
-          }));
-        },
-
-        componentOptions(): { label: string; value: string }[] {
-          return componentsStore.allComponents.map(
-            ({ displayName, id, schemaVariantId }) => ({
-              label: `${displayName} (${
-                this.nameForSchemaVariantId(schemaVariantId) ?? "unknown"
-              })`,
-              value: id,
-            }),
-          );
-        },
       },
 
       actions: {
-        propIdToSourceName(propId: string) {
-          const prop = this.propsForId[propId];
-          if (prop) {
-            return `Attribute: ${prop.path}`;
-          }
-        },
-        inputSocketIdToSourceName(inputSocketId: string) {
-          const socket = this.inputSocketForId(inputSocketId);
-          if (socket) {
-            return `Input Socket: ${socket.name}`;
-          }
-        },
-
-        outputSocketIdToSourceName(outputSocketId: string) {
-          const outputSocket = this.outputSocketsForId[outputSocketId];
-          if (outputSocket) {
-            return `Output Socket: ${outputSocket.name}`;
-          }
-          return undefined;
-        },
-
-        outputLocationForAttributePrototype(
-          prototype: AttributePrototypeBag,
-        ): OutputLocation | undefined {
-          if (prototype.propId) {
-            return {
-              label: this.propIdToSourceName(prototype.propId) ?? "none",
-              propId: prototype.propId,
-            };
-          }
-
-          if (prototype.outputSocketId) {
-            return {
-              label:
-                this.outputSocketIdToSourceName(prototype.outputSocketId) ??
-                "none",
-              outputSocketId: prototype.outputSocketId,
-            };
-          }
-
-          return undefined;
-        },
-
-        outputLocationOptionsForSchemaVariant(
-          schemaVariantId: string,
-        ): OutputLocationOption[] {
-          const propOptions =
-            (schemaVariantId === nilId()
-              ? _.flatten(Object.values(this.inputSourceProps))
-              : this.inputSourceProps[schemaVariantId]
-            )
-              ?.filter((p) => p.eligibleForOutput)
-              .map((prop) => {
-                const label = this.propIdToSourceName(prop.propId) ?? "none";
-                return {
-                  label,
-                  value: {
-                    label,
-                    propId: prop.propId,
-                  },
-                };
-              }) ?? [];
-
-          const socketOptions =
-            (schemaVariantId === nilId()
-              ? _.flatten(Object.values(this.outputSockets))
-              : this.outputSockets[schemaVariantId]
-            )?.map((socket) => {
-              const label =
-                this.outputSocketIdToSourceName(socket.outputSocketId) ??
-                "none";
-              return {
-                label,
-                value: {
-                  label,
-                  outputSocketId: socket.outputSocketId,
-                },
-              };
-            }) ?? [];
-          return [...propOptions, ...socketOptions];
-        },
-
         async FETCH_FUNC_LIST() {
-          return new ApiRequest<{ funcs: FuncSummary[] }, Visibility>({
-            url: "func/list_funcs",
-            params: {
-              ...visibility,
-            },
+          return new ApiRequest<FuncSummary[], Visibility>({
+            url: `${API_PREFIX}`,
             onSuccess: (response) => {
-              this.funcsById = _.keyBy(response.funcs, (f) => f.id);
+              response.forEach((func) => {
+                const bindings = processBindings(func);
+                this.actionBindings[func.funcId] = bindings.actionBindings;
+                this.attributeBindings[func.funcId] =
+                  bindings.attributeBindings;
+                this.authenticationBindings[func.funcId] =
+                  bindings.authenticationBindings;
+                this.qualificationBindings[func.funcId] =
+                  bindings.qualificationBindings;
+                this.codegenBindings[func.funcId] = bindings.codegenBindings;
+              });
+
+              this.funcsById = _.keyBy(response, (f) => f.funcId);
               this.recoverOpenFuncIds();
             },
           });
         },
-        async FETCH_FUNC(funcId: FuncId) {
-          return new ApiRequest<FuncWithDetails>({
-            url: "func/get_func",
+        async FETCH_CODE(funcId: FuncId) {
+          return new ApiRequest<FuncCode[]>({
+            url: `${API_PREFIX}/code`,
             params: {
               id: funcId,
-              ...visibility,
             },
             keyRequestStatusBy: funcId,
             onSuccess: (response) => {
-              this.funcDetailsById[response.id] = response;
+              response.forEach((func: FuncCode) => {
+                this.funcCodeById[func.funcId] = func;
+              });
             },
           });
         },
-        async FETCH_FUNC_ASSOCIATIONS(funcId: FuncId) {
-          return new ApiRequest<{ associations?: FuncAssociations }>({
-            url: "func/get_func_associations",
-            params: {
-              id: funcId,
-              ...visibility,
-            },
-            keyRequestStatusBy: funcId,
+        async CREATE_FUNC(createFuncRequest: {
+          name: string;
+          displayName: string;
+          description: string;
+          kind: FuncKind;
+          binding: FuncBinding;
+        }) {
+          if (changeSetsStore.creatingChangeSet)
+            throw new Error("race, wait until the change set is created");
+          if (changeSetsStore.headSelected)
+            changeSetsStore.creatingChangeSet = true;
+
+          return new ApiRequest<{ summary: FuncSummary; code: FuncCode }>({
+            method: "post",
+            url: `${API_PREFIX}/create`,
+            params: { ...createFuncRequest },
             onSuccess: (response) => {
-              const func = this.funcDetailsById[funcId];
-              if (func) {
-                func.associations = response.associations;
-                this.funcDetailsById[funcId] = func;
-              }
+              // summary coming through the WsEvent
+              this.funcCodeById[response.code.funcId] = response.code;
+              // select the fn to load it in the editor done in the component
+            },
+            onFail: () => {
+              changeSetsStore.creatingChangeSet = false;
             },
           });
         },
+        // TODO: jobelenus, doesn't exist yet...
         async DELETE_FUNC(funcId: FuncId) {
           return new ApiRequest<DeleteFuncResponse>({
             method: "post",
@@ -361,79 +218,58 @@ export const useFuncStore = () => {
             },
           });
         },
-        async UPDATE_FUNC(func: FuncWithDetails) {
+        async UPDATE_FUNC(func: FuncSummary) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
             changeSetsStore.creatingChangeSet = true;
           const isHead = changeSetsStore.headSelected;
 
-          return new ApiRequest<SaveFuncResponse>({
+          return new ApiRequest({
             method: "post",
-            url: "func/save_func",
+            url: `${API_PREFIX}/${func.funcId}/update`,
             params: {
-              ...func,
-              ...visibility,
+              displayName: func.displayName,
+              description: func.description,
             },
             optimistic: () => {
               if (isHead) return () => {};
 
-              const current = this.funcById(func.id);
-              this.funcDetailsById[func.id] = {
-                ...func,
-                code: current?.code ?? func.code,
-              };
+              const current = this.funcsById[func.funcId];
               return () => {
                 if (current) {
-                  this.funcDetailsById[func.id] = current;
+                  this.funcsById[func.funcId] = current;
                 } else {
-                  delete this.funcDetailsById[func.id];
+                  delete this.funcCodeById[func.funcId];
+                  delete this.funcsById[func.funcId];
                 }
               };
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
-            keyRequestStatusBy: func.id,
+            keyRequestStatusBy: func.funcId,
           });
         },
-        async CREATE_ATTRIBUTE_PROTOTYPE(
-          funcId: FuncId,
-          schemaVariantId: string,
-          prototypeArguments: AttributePrototypeArgumentBag[],
-          componentId?: string,
-          propId?: string,
-          outputSocketId?: string,
-        ) {
+        async CREATE_BINDING(funcId: FuncId, bindings: FuncBinding[]) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
             changeSetsStore.creatingChangeSet = true;
 
+          // TODO: jobelenus, handle this WsEvent (no funcId on it?!)
           return new ApiRequest<null>({
             method: "post",
-            url: "func/create_attribute_prototype",
+            url: `${API_PREFIX}/${funcId}/bindings/create`,
             params: {
-              funcId,
-              schemaVariantId,
-              componentId,
-              propId,
-              outputSocketId,
-              prototypeArguments,
-              ...visibility,
+              bindings,
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async UPDATE_ATTRIBUTE_PROTOTYPE(
-          funcId: FuncId,
-          attributePrototypeId: string,
-          prototypeArguments: AttributePrototypeArgumentBag[],
-          propId?: string,
-          outputSocketId?: string,
-        ) {
+        async UPDATE_BINDING(funcId: FuncId, bindings: FuncBinding[]) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
@@ -441,21 +277,18 @@ export const useFuncStore = () => {
 
           return new ApiRequest<null>({
             method: "post",
-            url: "func/update_attribute_prototype",
+            url: `${API_PREFIX}/${funcId}/bindings/update`,
             params: {
               funcId,
-              attributePrototypeId,
-              propId,
-              outputSocketId,
-              prototypeArguments,
-              ...visibility,
+              bindings,
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async REMOVE_ATTRIBUTE_PROTOTYPE(attributePrototypeId: string) {
+        // How you "DETACH" an attribute function
+        async RESET_ATTRIBUTE_BINDING(funcId: FuncId, bindings: FuncBinding[]) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
@@ -463,22 +296,17 @@ export const useFuncStore = () => {
 
           return new ApiRequest<null>({
             method: "post",
-            url: "func/remove_attribute_prototype",
+            url: `${API_PREFIX}/${funcId}/reset_attribute_binding`,
             params: {
-              attributePrototypeId,
-              ...visibility,
+              bindings,
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async CREATE_FUNC_ARGUMENT(
-          funcId: FuncId,
-          name: string,
-          kind: FuncArgumentKind,
-          elementKind?: FuncArgumentKind,
-        ) {
+        // How you "DETACH" all other function bindings
+        async DELETE_BINDING(funcId: FuncId, bindings: FuncBinding[]) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
@@ -486,26 +314,16 @@ export const useFuncStore = () => {
 
           return new ApiRequest<null>({
             method: "post",
-            url: "func/create_func_argument",
+            url: `${API_PREFIX}/${funcId}/bindings/delete`,
             params: {
-              funcId,
-              name,
-              kind,
-              elementKind,
-              ...visibility,
+              bindings,
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async UPDATE_FUNC_ARGUMENT(
-          funcId: FuncId,
-          funcArgumentId: FuncArgumentId,
-          name: string,
-          kind: FuncArgumentKind,
-          elementKind?: FuncArgumentKind,
-        ) {
+        async CREATE_FUNC_ARGUMENT(funcId: FuncId, funcArg: FuncArgument) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
@@ -513,24 +331,16 @@ export const useFuncStore = () => {
 
           return new ApiRequest<null>({
             method: "post",
-            url: "func/update_func_argument",
+            url: `${API_PREFIX}/${funcId}/create_argument`,
             params: {
-              funcId,
-              funcArgumentId,
-              name,
-              kind,
-              elementKind,
-              ...visibility,
+              ...funcArg,
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async DELETE_FUNC_ARGUMENT(
-          funcId: FuncId,
-          funcArgumentId: FuncArgumentId,
-        ) {
+        async UPDATE_FUNC_ARGUMENT(funcId: FuncId, funcArg: FuncArgument) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
@@ -538,141 +348,56 @@ export const useFuncStore = () => {
 
           return new ApiRequest<null>({
             method: "post",
-            url: "func/delete_func_argument",
+            url: `${API_PREFIX}/${funcId}/${funcArg.id}/update`,
             params: {
-              funcId,
-              funcArgumentId,
-              ...visibility,
+              ...funcArg,
             },
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async FETCH_FUNC_ARGUMENT_LIST(funcId: FuncId) {
-          return new ApiRequest<{ funcArguments: FuncArgument[] }>({
-            url: "func/list_func_arguments",
-            params: {
-              funcId,
-              ...visibility,
-            },
-            onSuccess: (response) => {
-              this.funcArgumentsByFuncId[funcId] = response.funcArguments;
-              for (const argument of response.funcArguments) {
-                this.funcArgumentsById[argument.id] = argument;
-              }
-            },
-          });
-        },
-        async SAVE_AND_EXEC_FUNC(funcId: FuncId) {
-          const func = this.funcById(funcId);
-          if (func) {
-            trackEvent("func_save_and_exec", { id: func.id, name: func.name });
-          }
-
+        async DELETE_FUNC_ARGUMENT(
+          funcId: FuncId,
+          funcArgumentId: FuncArgumentId,
+        ) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
             changeSetsStore.creatingChangeSet = true;
 
-          return new ApiRequest<SaveFuncResponse>({
+          return new ApiRequest<null>({
             method: "post",
-            url: "func/save_and_exec",
-            keyRequestStatusBy: funcId,
-            params: { ...func, ...visibility },
+            url: `${API_PREFIX}/${funcId}/${funcArgumentId}/delete`,
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async TEST_EXECUTE(executeRequest: {
-          id: FuncId;
-          args: unknown;
-          code: string;
-          componentId: string;
-        }) {
-          const func = this.funcById(executeRequest.id);
+        // TODO: jobelenus, is this still "save"? or *just* execute?
+        async SAVE_AND_EXEC_FUNC(funcId: FuncId) {
+          const func = this.funcsById[funcId];
           if (func) {
-            trackEvent("function_test_execute", {
-              id: func.id,
+            trackEvent("func_save_and_exec", {
+              id: func.funcId,
               name: func.name,
             });
           }
 
-          return new ApiRequest<{
-            funcRunId: FuncRunId;
-          }>({
-            method: "post",
-            url: "func/test_execute",
-            params: { ...executeRequest, ...visibility },
-          });
-        },
-        async CREATE_FUNC(createFuncRequest: {
-          kind: FuncKind;
-          name?: string;
-          options?: CreateFuncOptions;
-        }) {
           if (changeSetsStore.creatingChangeSet)
             throw new Error("race, wait until the change set is created");
           if (changeSetsStore.headSelected)
             changeSetsStore.creatingChangeSet = true;
 
-          return new ApiRequest<FuncSummary>({
+          return new ApiRequest({
             method: "post",
-            url: "func/create_func",
-            params: { ...createFuncRequest, ...visibility },
-            onSuccess: (response) => {
-              this.funcsById[response.id] = response;
-            },
+            url: `${API_PREFIX}/${funcId}/execute`,
+            keyRequestStatusBy: funcId,
             onFail: () => {
               changeSetsStore.creatingChangeSet = false;
             },
           });
         },
-        async FETCH_INPUT_SOURCE_LIST(schemaVariantId?: string) {
-          return new ApiRequest<{
-            inputSockets: InputSocketView[];
-            outputSockets: OutputSocketView[];
-            props: InputSourceProp[];
-          }>({
-            url: "func/list_input_sources",
-            params: { schemaVariantId, ...visibility },
-            onSuccess: (response) => {
-              const inputSourceSockets = this.inputSourceSockets;
-              const inputSourceSocketsFromResponse = _.groupBy(
-                response.inputSockets,
-                "schemaVariantId",
-              );
-              for (const schemaVariantId in inputSourceSocketsFromResponse) {
-                inputSourceSockets[schemaVariantId] =
-                  inputSourceSocketsFromResponse[schemaVariantId] ?? [];
-              }
-              this.inputSourceSockets = inputSourceSockets;
-
-              const inputSourceProps = this.inputSourceProps;
-              const inputSourcePropsFromResponse = _.groupBy(
-                response.props,
-                "schemaVariantId",
-              );
-              for (const _schemaVariantId in inputSourcePropsFromResponse) {
-                inputSourceProps[_schemaVariantId] =
-                  inputSourcePropsFromResponse[_schemaVariantId] ?? [];
-              }
-              this.inputSourceProps = inputSourceProps;
-
-              const outputSockets = this.outputSockets;
-              const outputSocketsFromResponse = _.groupBy(
-                response.outputSockets,
-                "schemaVariantId",
-              );
-              for (const _schemaVariantId in outputSocketsFromResponse) {
-                outputSockets[_schemaVariantId] =
-                  outputSocketsFromResponse[_schemaVariantId] ?? [];
-              }
-              this.outputSockets = outputSockets;
-            },
-          });
-        },
         async FETCH_PROTOTYPE_ARGUMENTS(
           propId?: string,
           outputSocketId?: string,
@@ -684,6 +409,29 @@ export const useFuncStore = () => {
             params: { propId, outputSocketId, ...visibility },
           });
         },
+        async TEST_EXECUTE(executeRequest: {
+          funcId: FuncId;
+          args: unknown;
+          code: string;
+          componentId: string;
+        }) {
+          const func = this.funcsById[executeRequest.funcId];
+          if (func) {
+            trackEvent("function_test_execute", {
+              id: func.funcId,
+              name: func.name,
+            });
+          }
+
+          // why aren't we doing anything with the result of this?!
+          return new ApiRequest<{
+            funcRunId: FuncRunId;
+          }>({
+            method: "post",
+            url: `${API_PREFIX}/${executeRequest.funcId}/test_execute`,
+            params: { ...executeRequest },
+          });
+        },
 
         async recoverOpenFuncIds() {
           // fetch the list of open funcs from localstorage
@@ -717,38 +465,48 @@ export const useFuncStore = () => {
         },
 
         updateFuncCode(funcId: FuncId, code: string) {
-          const func = _.cloneDeep(this.funcDetailsById[funcId]);
+          const func = _.cloneDeep(this.funcCodeById[funcId]);
           if (!func || func.code === code) return;
           func.code = code;
 
           this.enqueueFuncSave(func);
         },
 
-        enqueueFuncSave(func: FuncWithDetails) {
-          if (changeSetsStore.headSelected) return this.UPDATE_FUNC(func);
-
-          this.funcDetailsById[func.id] = func;
+        enqueueFuncSave(func: FuncCode) {
+          this.editingFuncLatestCode[func.funcId] = func.code;
 
           // Lots of ways to handle this... we may want to handle this debouncing in the component itself
           // so the component has its own "draft" state that it passes back to the store when it's ready to save
           // however this should work for now, and lets the store handle this logic
           if (!funcSaveDebouncer) {
             funcSaveDebouncer = keyedDebouncer((id: FuncId) => {
-              const f = this.funcDetailsById[id];
-              if (!f) return;
-              this.UPDATE_FUNC(f);
+              const f = this.funcCodeById[id];
+              const code = this.editingFuncLatestCode[id];
+              if (!f || !code) return;
+              f.code = code;
+              this.SAVE_FUNC(f);
             }, 500);
           }
           // call debounced function which will trigger sending the save to the backend
-          const saveFunc = funcSaveDebouncer(func.id);
+          const saveFunc = funcSaveDebouncer(func.funcId);
           if (saveFunc) {
-            saveFunc(func.id);
+            saveFunc(func.funcId);
           }
         },
+
+        async SAVE_FUNC(func: FuncCode) {
+          return new ApiRequest<FuncCode>({
+            method: "post",
+            url: `${API_PREFIX}/${func.funcId}/save_code`,
+            params: { code: func.code },
+            onFail: () => {
+              changeSetsStore.creatingChangeSet = false;
+            },
+          });
+        },
       },
       onActivated() {
         this.FETCH_FUNC_LIST();
-        this.FETCH_INPUT_SOURCE_LIST();
 
         const assetStore = useAssetStore();
         const realtimeStore = useRealtimeStore();
@@ -760,12 +518,34 @@ export const useFuncStore = () => {
               this.FETCH_FUNC_LIST();
             },
           },
-          // TODO(victor) we don't need the changeSetId checks below, since nats filters messages already
           {
-            eventType: "FuncCreated",
+            eventType: "FuncBindingsUpdated",
             callback: (data) => {
               if (data.changeSetId !== selectedChangeSetId) return;
-              this.FETCH_FUNC_LIST();
+              // all the bindings for one given func
+              const funcId = data.bindings[0]?.funcId;
+              if (funcId) {
+                const func = this.funcsById[funcId];
+                if (func) func.bindings = data.bindings;
+              }
+            },
+          },
+          {
+            eventType: "FuncUpdated",
+            callback: (data) => {
+              if (data.changeSetId !== selectedChangeSetId) return;
+              this.funcsById[data.funcSummary.funcId] = data.funcSummary;
+              const bindings = processBindings(data.funcSummary);
+              this.actionBindings[data.funcSummary.funcId] =
+                bindings.actionBindings;
+              this.attributeBindings[data.funcSummary.funcId] =
+                bindings.attributeBindings;
+              this.authenticationBindings[data.funcSummary.funcId] =
+                bindings.authenticationBindings;
+              this.qualificationBindings[data.funcSummary.funcId] =
+                bindings.qualificationBindings;
+              this.codegenBindings[data.funcSummary.funcId] =
+                bindings.codegenBindings;
             },
           },
           {
@@ -784,27 +564,22 @@ export const useFuncStore = () => {
               }
             },
           },
-          {
-            eventType: "FuncArgumentsSaved",
-            callback: (data) => {
-              if (data.changeSetId !== selectedChangeSetId) return;
-              if (data.funcId !== this.selectedFuncId) return;
-              this.FETCH_FUNC_ARGUMENT_LIST(data.funcId);
-              this.FETCH_FUNC(data.funcId);
-            },
-          },
           {
             eventType: "FuncSaved",
             callback: (data) => {
               if (data.changeSetId !== selectedChangeSetId) return;
+              // TODO: jobelenus, send data over the wire so i dont need this call
               this.FETCH_FUNC_LIST();
 
               // Reload the last selected asset to ensure that its func list is up to date.
+              // TODO: jobelenus, move this to the asset store!
               const assetId = assetStore.selectedVariantId;
               if (assetId) {
                 assetStore.LOAD_SCHEMA_VARIANT(assetId);
               }
 
+              // TODO, i dont know how this would ever fire to someone sitting on head?
+              // wouldn't we listen for an event "changeset applied"???
               if (this.selectedFuncId) {
                 // Only fetch if we don't have the selected func in our state or if we are on HEAD.
                 // If we are on HEAD, the func is immutable, so we are safe to fetch. However, if
@@ -813,13 +588,11 @@ export const useFuncStore = () => {
                 // value before the save queue is drained.
                 if (data.funcId === this.selectedFuncId) {
                   if (
-                    typeof this.funcDetailsById[this.selectedFuncId] ===
+                    typeof this.funcCodeById[this.selectedFuncId] ===
                       "undefined" ||
                     changeSetsStore.headSelected
                   ) {
-                    this.FETCH_FUNC(this.selectedFuncId);
-                  } else {
-                    this.FETCH_FUNC_ASSOCIATIONS(this.selectedFuncId);
+                    this.FETCH_CODE(this.selectedFuncId);
                   }
                 }
               }
diff --git a/app/web/src/store/func/types.ts b/app/web/src/store/func/types.ts
deleted file mode 100644
index 7263cb5b00..0000000000
--- a/app/web/src/store/func/types.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { PropKind } from "@/api/sdf/dal/prop";
-import { ActionKind } from "@/store/actions.store";
-
-export interface ActionAssociations {
-  type: "action";
-  schemaVariantIds: string[];
-  kind?: ActionKind;
-}
-
-export type LeafInputLocation =
-  | "code"
-  | "deletedAt"
-  | "domain"
-  | "resource"
-  | "secrets";
-
-export interface AuthenticationAssociations {
-  type: "authentication";
-  schemaVariantIds: string[];
-}
-
-export interface CodeGenerationAssociations {
-  type: "codeGeneration";
-  schemaVariantIds: string[];
-  componentIds: string[];
-  inputs: LeafInputLocation[];
-}
-
-export interface QualificationAssociations {
-  type: "qualification";
-  schemaVariantIds: string[];
-  componentIds: string[];
-  inputs: LeafInputLocation[];
-}
-
-export interface AttributePrototypeArgumentBag {
-  funcArgumentId: string;
-  id?: string;
-  propId?: string;
-  inputSocketId?: string;
-}
-
-export interface AttributePrototypeBag {
-  id: string;
-  componentId?: string;
-  schemaVariantId?: string;
-  propId?: string;
-  outputSocketId?: string;
-  prototypeArguments: AttributePrototypeArgumentBag[];
-}
-
-export interface AttributeAssociations {
-  type: "attribute";
-  prototypes: AttributePrototypeBag[];
-}
-
-export type FuncAssociations =
-  | AuthenticationAssociations
-  | ActionAssociations
-  | AttributeAssociations
-  | CodeGenerationAssociations
-  | QualificationAssociations;
-
-export interface InputSocketView {
-  schemaVariantId: string;
-  inputSocketId: string;
-  name: string;
-}
-
-export interface OutputSocketView {
-  schemaVariantId: string;
-  outputSocketId: string;
-  name: string;
-}
-
-export interface InputSourceProp {
-  propId: string;
-  kind: PropKind;
-  schemaVariantId: string;
-  path: string;
-  name: string;
-  eligibleForOutput: boolean;
-}
-
-export interface OutputLocationProp {
-  label: string;
-  propId: string;
-}
-
-export interface OutputLocationOutputSocket {
-  label: string;
-  outputSocketId: string;
-}
-
-export type OutputLocation = OutputLocationProp | OutputLocationOutputSocket;
-
-export interface CreateFuncAttributeOutputLocationProp {
-  type: "prop";
-  propId: string;
-}
-
-export interface CreateFuncAttributeOutputLocationOutputSocket {
-  type: "outputSocket";
-  outputSocketId: string;
-}
-
-export type CreateFuncOutputLocation =
-  | CreateFuncAttributeOutputLocationOutputSocket
-  | CreateFuncAttributeOutputLocationProp;
-
-export interface CreateFuncAuthenticationOptions {
-  type: "authenticationOptions";
-  schemaVariantId: string;
-}
-
-export interface CreateFuncAttributeOptions {
-  type: "attributeOptions";
-  outputLocation: CreateFuncOutputLocation;
-}
-
-export interface CreateFuncActionOptions {
-  type: "actionOptions";
-  schemaVariantId: string;
-  actionKind: ActionKind;
-}
-
-export interface CreateFuncQualificationOptions {
-  type: "qualificationOptions";
-  schemaVariantId: string;
-}
-
-export interface CreateFuncCodeGenerationOptions {
-  type: "codeGenerationOptions";
-  schemaVariantId: string;
-}
-
-export type CreateFuncOptions =
-  | CreateFuncAuthenticationOptions
-  | CreateFuncActionOptions
-  | CreateFuncAttributeOptions
-  | CreateFuncCodeGenerationOptions
-  | CreateFuncQualificationOptions;
diff --git a/app/web/src/store/func_runs.store.ts b/app/web/src/store/func_runs.store.ts
index 7d2dad9833..e29cbbfeed 100644
--- a/app/web/src/store/func_runs.store.ts
+++ b/app/web/src/store/func_runs.store.ts
@@ -7,7 +7,7 @@ import {
   ActionKind,
   ActionPrototypeId,
   ActionResultState,
-} from "./actions.store";
+} from "@/api/sdf/dal/action";
 import { useWorkspacesStore } from "./workspaces.store";
 import { AttributeValueId } from "./status.store";
 import { useChangeSetsStore } from "./change_sets.store";
diff --git a/app/web/src/store/realtime/realtime_events.ts b/app/web/src/store/realtime/realtime_events.ts
index f55c14c589..122542b204 100644
--- a/app/web/src/store/realtime/realtime_events.ts
+++ b/app/web/src/store/realtime/realtime_events.ts
@@ -1,13 +1,13 @@
 // This is a map of valid websocket events to the shape of their payload
 // used in the subscribe fn to limit valid event names and set callback payload type
 
-import { FuncId } from "@/api/sdf/dal/func";
+import { FuncBinding, FuncId, FuncSummary } from "@/api/sdf/dal/func";
 import { ChangeSetId } from "@/api/sdf/dal/change_set";
 import { ComponentId, RawComponent, RawEdge } from "@/api/sdf/dal/component";
 import { ComponentType, SchemaVariant } from "@/api/sdf/dal/schema";
+import { ActionId } from "@/api/sdf/dal/action";
 import { ComponentGeometry } from "../components.store";
 import { WorkspacePk } from "../workspaces.store";
-import { ActionId } from "../actions.store";
 import { StatusUpdate } from "../status.store";
 import { CursorContainerKind } from "../presence.store";
 import { UserId } from "../auth.store";
@@ -254,6 +254,7 @@ export type WsEventPayloadMap = {
     changeSetId: ChangeSetId;
   };
   SchemaVariantCreated: SchemaVariant;
+  SchemaVariantUpdated: SchemaVariant;
   SchemaVariantCloned: {
     schemaVariantId: string;
     changeSetId: ChangeSetId;
@@ -275,8 +276,19 @@ export type WsEventPayloadMap = {
     link?: string;
     description?: string;
   };
+  FuncBindingsUpdated: {
+    types: string;
+    bindings: FuncBinding[];
+    changeSetId: ChangeSetId;
+  };
   FuncCreated: {
-    funcId: FuncId;
+    types: string;
+    funcSummary: FuncSummary;
+    changeSetId: ChangeSetId;
+  };
+  FuncUpdated: {
+    types: string;
+    funcSummary: FuncSummary;
     changeSetId: ChangeSetId;
   };
   FuncDeleted: {
diff --git a/lib/sdf-server/src/server/service/v2/func.rs b/lib/sdf-server/src/server/service/v2/func.rs
index 15ea312c31..43ddf996e3 100644
--- a/lib/sdf-server/src/server/service/v2/func.rs
+++ b/lib/sdf-server/src/server/service/v2/func.rs
@@ -120,18 +120,10 @@ pub fn v2_routes() -> Router<AppState> {
             post(binding::update_binding::update_binding),
         )
         // Attribute Bindings
-        .route(
-            "/:func_id/create_attribute_binding",
-            post(binding::attribute::create_attribute_binding::create_attribute_binding),
-        )
         .route(
             "/:func_id/reset_attribute_binding",
             post(binding::attribute::reset_attribute_binding::reset_attribute_binding),
         )
-        .route(
-            "/:func_id/update_attribute_binding",
-            post(binding::attribute::update_attribute_binding::update_attribute_binding),
-        )
         // Func Arguments
         .route(
             "/:func_id/:func_argument_id/update",
diff --git a/lib/sdf-server/src/server/service/v2/func/binding/attribute.rs b/lib/sdf-server/src/server/service/v2/func/binding/attribute.rs
index 0e4133c3d1..d6f09e71bf 100644
--- a/lib/sdf-server/src/server/service/v2/func/binding/attribute.rs
+++ b/lib/sdf-server/src/server/service/v2/func/binding/attribute.rs
@@ -1,3 +1 @@
-pub mod create_attribute_binding;
 pub mod reset_attribute_binding;
-pub mod update_attribute_binding;
diff --git a/lib/sdf-server/src/server/service/v2/func/binding/attribute/create_attribute_binding.rs b/lib/sdf-server/src/server/service/v2/func/binding/attribute/create_attribute_binding.rs
deleted file mode 100644
index d172f86326..0000000000
--- a/lib/sdf-server/src/server/service/v2/func/binding/attribute/create_attribute_binding.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-use axum::{
-    extract::{OriginalUri, Path},
-    response::IntoResponse,
-    Json,
-};
-use dal::{
-    func::binding::{attribute::AttributeBinding, AttributeArgumentBinding, FuncBindings},
-    ChangeSet, ChangeSetId, Func, FuncId, WorkspacePk, WsEvent,
-};
-use si_frontend_types::{self as frontend_types};
-
-use crate::{
-    server::{
-        extract::{AccessBuilder, HandlerContext, PosthogClient},
-        tracking::track,
-    },
-    service::v2::func::{get_types, FuncAPIError, FuncAPIResult},
-};
-
-pub async fn create_attribute_binding(
-    HandlerContext(builder): HandlerContext,
-    AccessBuilder(access_builder): AccessBuilder,
-    PosthogClient(posthog_client): PosthogClient,
-    OriginalUri(original_uri): OriginalUri,
-    Path((_workspace_pk, change_set_id, func_id)): Path<(WorkspacePk, ChangeSetId, FuncId)>,
-    Json(request): Json<frontend_types::FuncBindings>,
-) -> FuncAPIResult<impl IntoResponse> {
-    let mut ctx = builder
-        .build(access_builder.build(change_set_id.into()))
-        .await?;
-    let force_change_set_id = ChangeSet::force_new(&mut ctx).await?;
-    let func = Func::get_by_id_or_error(&ctx, func_id).await?;
-    match func.kind {
-        dal::func::FuncKind::Attribute => {
-            for binding in request.bindings {
-                if let frontend_types::FuncBinding::Attribute {
-                    func_id,
-                    component_id,
-                    schema_variant_id,
-                    prop_id,
-                    output_socket_id,
-                    argument_bindings,
-                    ..
-                } = binding
-                {
-                    match func_id {
-                        Some(func_id) => {
-                            let eventual_parent = AttributeBinding::assemble_eventual_parent(
-                                &ctx,
-                                component_id,
-                                schema_variant_id,
-                            )
-                            .await?;
-                            let attribute_output_location =
-                                AttributeBinding::assemble_attribute_output_location(
-                                    prop_id,
-                                    output_socket_id,
-                                )?;
-                            let mut arguments: Vec<AttributeArgumentBinding> = vec![];
-                            for arg_binding in argument_bindings {
-                                let input_location =
-                                    AttributeArgumentBinding::assemble_attribute_input_location(
-                                        arg_binding.prop_id,
-                                        arg_binding.input_socket_id,
-                                    )?;
-                                arguments.push(AttributeArgumentBinding {
-                                    func_argument_id: arg_binding
-                                        .func_argument_id
-                                        .into_raw_id()
-                                        .into(),
-                                    attribute_func_input_location: input_location,
-                                    attribute_prototype_argument_id: None, // when creating a new prototype,
-                                                                           // we don't have the attribute prototype arguments yet
-                                });
-                            }
-
-                            AttributeBinding::upsert_attribute_binding(
-                                &ctx,
-                                func_id.into_raw_id().into(),
-                                eventual_parent,
-                                attribute_output_location,
-                                arguments,
-                            )
-                            .await?;
-                        }
-                        None => {
-                            return Err(FuncAPIError::MissingFuncId);
-                        }
-                    }
-                }
-            }
-        }
-        _ => {
-            return Err(FuncAPIError::WrongFunctionKindForBinding);
-        }
-    };
-    track(
-        &posthog_client,
-        &ctx,
-        &original_uri,
-        "created_attribute_binding",
-        serde_json::json!({
-            "how": "/func/created_binding",
-            "func_id": func_id,
-            "func_name": func.name.clone(),
-            "func_kind": func.kind.clone(),
-        }),
-    );
-    let types = get_types(&ctx, func_id).await?;
-
-    let binding = FuncBindings::from_func_id(&ctx, func_id)
-        .await?
-        .into_frontend_type();
-    WsEvent::func_bindings_updated(&ctx, binding.clone(), types)
-        .await?
-        .publish_on_commit(&ctx)
-        .await?;
-    ctx.commit().await?;
-
-    let mut response = axum::response::Response::builder();
-    response = response.header("Content-Type", "application/json");
-    if let Some(force_change_set_id) = force_change_set_id {
-        response = response.header("force_change_set_id", force_change_set_id.to_string());
-    }
-    Ok(response.body(serde_json::to_string(&binding)?)?)
-}
diff --git a/lib/sdf-server/src/server/service/v2/func/binding/attribute/update_attribute_binding.rs b/lib/sdf-server/src/server/service/v2/func/binding/attribute/update_attribute_binding.rs
deleted file mode 100644
index 1c95be3e50..0000000000
--- a/lib/sdf-server/src/server/service/v2/func/binding/attribute/update_attribute_binding.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use axum::{
-    extract::{OriginalUri, Path},
-    response::IntoResponse,
-    Json,
-};
-use dal::{
-    func::binding::{attribute::AttributeBinding, AttributeArgumentBinding, FuncBindings},
-    ChangeSet, ChangeSetId, Func, FuncId, WorkspacePk, WsEvent,
-};
-use si_frontend_types::{self as frontend_types};
-
-use crate::{
-    server::{
-        extract::{AccessBuilder, HandlerContext, PosthogClient},
-        tracking::track,
-    },
-    service::v2::func::{get_types, FuncAPIError, FuncAPIResult},
-};
-
-pub async fn update_attribute_binding(
-    HandlerContext(builder): HandlerContext,
-    AccessBuilder(access_builder): AccessBuilder,
-    PosthogClient(posthog_client): PosthogClient,
-    OriginalUri(original_uri): OriginalUri,
-    Path((_workspace_pk, change_set_id, func_id)): Path<(WorkspacePk, ChangeSetId, FuncId)>,
-    Json(request): Json<frontend_types::FuncBindings>,
-) -> FuncAPIResult<impl IntoResponse> {
-    let mut ctx = builder
-        .build(access_builder.build(change_set_id.into()))
-        .await?;
-    let force_change_set_id = ChangeSet::force_new(&mut ctx).await?;
-    let func = Func::get_by_id_or_error(&ctx, func_id).await?;
-    match func.kind {
-        dal::func::FuncKind::Attribute => {
-            for binding in request.bindings {
-                if let frontend_types::FuncBinding::Attribute {
-                    argument_bindings,
-                    attribute_prototype_id,
-                    ..
-                } = binding
-                {
-                    match attribute_prototype_id {
-                        Some(attribute_prototype_id) => {
-                            let mut arguments: Vec<AttributeArgumentBinding> = vec![];
-                            for arg_binding in argument_bindings {
-                                let input_location =
-                                    AttributeArgumentBinding::assemble_attribute_input_location(
-                                        arg_binding.prop_id,
-                                        arg_binding.input_socket_id,
-                                    )?;
-                                arguments.push(AttributeArgumentBinding {
-                                    func_argument_id: arg_binding
-                                        .func_argument_id
-                                        .into_raw_id()
-                                        .into(),
-                                    attribute_func_input_location: input_location,
-                                    attribute_prototype_argument_id: None, // when creating a new prototype,
-                                                                           // we don't have the attribute prototype arguments yet
-                                });
-                            }
-
-                            AttributeBinding::update_attribute_binding_arguments(
-                                &ctx,
-                                attribute_prototype_id.into_raw_id().into(),
-                                arguments,
-                            )
-                            .await?;
-                        }
-                        None => return Err(FuncAPIError::MissingPrototypeId),
-                    }
-                }
-            }
-        }
-        _ => {
-            return Err(FuncAPIError::WrongFunctionKindForBinding);
-        }
-    };
-    track(
-        &posthog_client,
-        &ctx,
-        &original_uri,
-        "update_attribute_binding",
-        serde_json::json!({
-            "how": "/func/update_attribute_binding",
-            "func_id": func_id,
-            "func_name": func.name.clone(),
-            "func_kind": func.kind.clone(),
-        }),
-    );
-    let binding = FuncBindings::from_func_id(&ctx, func_id)
-        .await?
-        .into_frontend_type();
-    let types = get_types(&ctx, func_id).await?;
-    WsEvent::func_bindings_updated(&ctx, binding.clone(), types)
-        .await?
-        .publish_on_commit(&ctx)
-        .await?;
-    ctx.commit().await?;
-
-    let mut response = axum::response::Response::builder();
-    response = response.header("Content-Type", "application/json");
-    if let Some(force_change_set_id) = force_change_set_id {
-        response = response.header("force_change_set_id", force_change_set_id.to_string());
-    }
-    Ok(response.body(serde_json::to_string(&binding)?)?)
-}
diff --git a/lib/sdf-server/src/server/service/v2/func/binding/create_binding.rs b/lib/sdf-server/src/server/service/v2/func/binding/create_binding.rs
index 0675e897c5..6bfcb01079 100644
--- a/lib/sdf-server/src/server/service/v2/func/binding/create_binding.rs
+++ b/lib/sdf-server/src/server/service/v2/func/binding/create_binding.rs
@@ -4,7 +4,10 @@ use axum::{
     Json,
 };
 use dal::{
-    func::binding::{action::ActionBinding, leaf::LeafBinding, EventualParent, FuncBindings},
+    func::binding::{
+        action::ActionBinding, attribute::AttributeBinding, authentication::AuthBinding,
+        leaf::LeafBinding, AttributeArgumentBinding, EventualParent, FuncBindings,
+    },
     schema::variant::leaves::{LeafInputLocation, LeafKind},
     ChangeSet, ChangeSetId, Func, FuncId, WorkspacePk, WsEvent,
 };
@@ -32,6 +35,81 @@ pub async fn create_binding(
     let force_change_set_id = ChangeSet::force_new(&mut ctx).await?;
     let func = Func::get_by_id_or_error(&ctx, func_id).await?;
     match func.kind {
+        dal::func::FuncKind::Attribute => {
+            for binding in request.bindings {
+                if let frontend_types::FuncBinding::Attribute {
+                    func_id,
+                    component_id,
+                    schema_variant_id,
+                    prop_id,
+                    output_socket_id,
+                    argument_bindings,
+                    ..
+                } = binding
+                {
+                    match func_id {
+                        Some(func_id) => {
+                            let eventual_parent = AttributeBinding::assemble_eventual_parent(
+                                &ctx,
+                                component_id,
+                                schema_variant_id,
+                            )
+                            .await?;
+                            let attribute_output_location =
+                                AttributeBinding::assemble_attribute_output_location(
+                                    prop_id,
+                                    output_socket_id,
+                                )?;
+                            let mut arguments: Vec<AttributeArgumentBinding> = vec![];
+                            for arg_binding in argument_bindings {
+                                let input_location =
+                                    AttributeArgumentBinding::assemble_attribute_input_location(
+                                        arg_binding.prop_id,
+                                        arg_binding.input_socket_id,
+                                    )?;
+                                arguments.push(AttributeArgumentBinding {
+                                    func_argument_id: arg_binding
+                                        .func_argument_id
+                                        .into_raw_id()
+                                        .into(),
+                                    attribute_func_input_location: input_location,
+                                    attribute_prototype_argument_id: None, // when creating a new prototype,
+                                                                           // we don't have the attribute prototype arguments yet
+                                });
+                            }
+
+                            AttributeBinding::upsert_attribute_binding(
+                                &ctx,
+                                func_id.into_raw_id().into(),
+                                eventual_parent,
+                                attribute_output_location,
+                                arguments,
+                            )
+                            .await?;
+                        }
+                        None => {
+                            return Err(FuncAPIError::MissingFuncId);
+                        }
+                    }
+                }
+            }
+        }
+        dal::func::FuncKind::Authentication => {
+            for binding in request.bindings {
+                if let frontend_types::FuncBinding::Authentication {
+                    schema_variant_id,
+                    func_id,
+                } = binding
+                {
+                    AuthBinding::create_auth_binding(
+                        &ctx,
+                        func_id.into(),
+                        schema_variant_id.into(),
+                    )
+                    .await?;
+                }
+            }
+        }
         dal::func::FuncKind::Action => {
             for binding in request.bindings {
                 if let frontend_types::FuncBinding::Action {
diff --git a/lib/sdf-server/src/server/service/v2/func/binding/update_binding.rs b/lib/sdf-server/src/server/service/v2/func/binding/update_binding.rs
index 4785e8eb19..5f53f13a5d 100644
--- a/lib/sdf-server/src/server/service/v2/func/binding/update_binding.rs
+++ b/lib/sdf-server/src/server/service/v2/func/binding/update_binding.rs
@@ -4,7 +4,10 @@ use axum::{
     Json,
 };
 use dal::{
-    func::binding::{action::ActionBinding, leaf::LeafBinding, FuncBindings},
+    func::binding::{
+        action::ActionBinding, attribute::AttributeBinding, leaf::LeafBinding,
+        AttributeArgumentBinding, FuncBindings,
+    },
     schema::variant::leaves::LeafInputLocation,
     ChangeSet, ChangeSetId, Func, FuncId, WorkspacePk, WsEvent,
 };
@@ -32,6 +35,46 @@ pub async fn update_binding(
     let force_change_set_id = ChangeSet::force_new(&mut ctx).await?;
     let func = Func::get_by_id_or_error(&ctx, func_id).await?;
     match func.kind {
+        dal::func::FuncKind::Attribute => {
+            for binding in request.bindings {
+                if let frontend_types::FuncBinding::Attribute {
+                    argument_bindings,
+                    attribute_prototype_id,
+                    ..
+                } = binding
+                {
+                    match attribute_prototype_id {
+                        Some(attribute_prototype_id) => {
+                            let mut arguments: Vec<AttributeArgumentBinding> = vec![];
+                            for arg_binding in argument_bindings {
+                                let input_location =
+                                    AttributeArgumentBinding::assemble_attribute_input_location(
+                                        arg_binding.prop_id,
+                                        arg_binding.input_socket_id,
+                                    )?;
+                                arguments.push(AttributeArgumentBinding {
+                                    func_argument_id: arg_binding
+                                        .func_argument_id
+                                        .into_raw_id()
+                                        .into(),
+                                    attribute_func_input_location: input_location,
+                                    attribute_prototype_argument_id: None, // when creating a new prototype,
+                                                                           // we don't have the attribute prototype arguments yet
+                                });
+                            }
+
+                            AttributeBinding::update_attribute_binding_arguments(
+                                &ctx,
+                                attribute_prototype_id.into_raw_id().into(),
+                                arguments,
+                            )
+                            .await?;
+                        }
+                        None => return Err(FuncAPIError::MissingPrototypeId),
+                    }
+                }
+            }
+        }
         dal::func::FuncKind::Action => {
             for binding in request.bindings {
                 if let frontend_types::FuncBinding::Action {
diff --git a/lib/sdf-server/src/server/service/v2/func/get_code.rs b/lib/sdf-server/src/server/service/v2/func/get_code.rs
index 38001479b3..9141a09f2f 100644
--- a/lib/sdf-server/src/server/service/v2/func/get_code.rs
+++ b/lib/sdf-server/src/server/service/v2/func/get_code.rs
@@ -1,5 +1,5 @@
 use axum::{
-    extract::{OriginalUri, Path},
+    extract::{OriginalUri, Path, Query},
     Json,
 };
 use dal::{ChangeSetId, FuncId, WorkspacePk};
@@ -13,8 +13,12 @@ use super::{get_code_response, FuncAPIResult};
 
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
+
+// TODO: find the right way to pass a Vec<FuncId>
+// the API call uses the `id[]=<...>&id[]=<...?` format
+// but that doesn't work here with Rust
 pub struct GetRequest {
-    pub func_ids: Vec<FuncId>,
+    pub id: FuncId,
 }
 
 pub async fn get_code(
@@ -23,15 +27,13 @@ pub async fn get_code(
     PosthogClient(_posthog_client): PosthogClient,
     OriginalUri(_original_uri): OriginalUri,
     Path((_workspace_pk, change_set_id)): Path<(WorkspacePk, ChangeSetId)>,
-    Json(request): Json<GetRequest>,
+    Query(request): Query<GetRequest>,
 ) -> FuncAPIResult<Json<Vec<FuncCode>>> {
     let ctx = builder
         .build(access_builder.build(change_set_id.into()))
         .await?;
     let mut funcs = Vec::new();
 
-    for func_id in request.func_ids {
-        funcs.push(get_code_response(&ctx, func_id).await?);
-    }
+    funcs.push(get_code_response(&ctx, request.id).await?);
     Ok(Json(funcs))
 }
diff --git a/lib/sdf-server/src/server/service/v2/func/save_code.rs b/lib/sdf-server/src/server/service/v2/func/save_code.rs
index c62c0f51ef..25b438bbff 100644
--- a/lib/sdf-server/src/server/service/v2/func/save_code.rs
+++ b/lib/sdf-server/src/server/service/v2/func/save_code.rs
@@ -8,6 +8,7 @@ use dal::{
     func::authoring::FuncAuthoringClient, ChangeSet, ChangeSetId, Func, FuncId, WorkspacePk,
     WsEvent,
 };
+use serde::{Deserialize, Serialize};
 
 use crate::server::{
     extract::{AccessBuilder, HandlerContext, PosthogClient},
@@ -16,20 +17,26 @@ use crate::server::{
 
 use super::{get_code_response, FuncAPIResult};
 
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveCodeRequest {
+    pub code: String,
+}
+
 pub async fn save_code(
     HandlerContext(builder): HandlerContext,
     AccessBuilder(access_builder): AccessBuilder,
     PosthogClient(posthog_client): PosthogClient,
     OriginalUri(original_uri): OriginalUri,
     Path((_workspace_pk, change_set_id, func_id)): Path<(WorkspacePk, ChangeSetId, FuncId)>,
-    Json(request): Json<String>,
+    Json(request): Json<SaveCodeRequest>,
 ) -> FuncAPIResult<impl IntoResponse> {
     let mut ctx = builder
         .build(access_builder.build(change_set_id.into()))
         .await?;
     let force_change_set_id = ChangeSet::force_new(&mut ctx).await?;
 
-    FuncAuthoringClient::save_code(&ctx, func_id, request).await?;
+    FuncAuthoringClient::save_code(&ctx, func_id, request.code).await?;
     let func_code = get_code_response(&ctx, func_id).await?;
     let func = Func::get_by_id_or_error(&ctx, func_id).await?;
     WsEvent::func_code_saved(&ctx, func_code)