@beyondwork/docx-react-component 1.0.133 → 1.0.134

package/dist/{chunk-OTRVGNZQ.js → chunk-ESEEWELA.js}

@@ -18,7 +18,7 @@ import {
   resolveScopeRange,
   scopeSpecificity,
   searchDocument
-} from "./chunk-224TSMEB.js";
+} from "./chunk-IJD6D7HU.js";
 import {
   BROADCAST_COMMAND_TYPES,
   COMMAND_EVENT_SCHEMA_VERSION,
@@ -37,7 +37,7 @@ import {
   LAYCACHE_SCHEMA_VERSION,
   LAYOUT_ENGINE_VERSION,
   createScopeTagRegistry
-} from "./chunk-CVSD3UNK.js";
+} from "./chunk-O4EDZR44.js";
 import {
   chartModelStore,
   createEditorSurfaceSnapshot,
@@ -7224,6 +7224,216 @@ function createOutlineFamily(runtime) {
   };
 }
 
+// src/api/v3/ai/object.ts
+var applyObjectActionMetadata = {
+  name: "ai.applyObjectAction",
+  status: "live-with-adapter",
+  sourceLayer: "runtime-core",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-object-actions.test.ts",
+    commit: "refactor-09-object-actions"
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "image object layout changes"
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "scope",
+    auditCategory: "object-action-apply",
+    contextPromptShape: "Apply an image object layout operation to an opaque actionHandle from ai.listObjectActions; preserve-only objects return typed blockers."
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference: "\xA7AI API \xA7 ai.applyObjectAction"
+};
+function createObjectActionFamily(runtime) {
+  const compiler = createScopeCompilerService(runtime);
+  return {
+    listObjectActions(input) {
+      const bundle = compiler.compileBundleById(input.handle.scopeId, input.nowUtc);
+      if (!bundle) {
+        return {
+          scopeId: input.handle.scopeId,
+          actions: [],
+          blockers: [`scope-not-resolvable:${input.handle.scopeId}`]
+        };
+      }
+      const seed = documentSeed2(runtime);
+      return {
+        scopeId: input.handle.scopeId,
+        actions: bundle.evidence.editableTargets?.entries.filter(isSupportedImageObjectEvidence).map((entry) => projectObjectDescriptor(runtime, seed, entry)) ?? []
+      };
+    },
+    applyObjectAction(input) {
+      emitUxResponse(runtime, {
+        apiFn: applyObjectActionMetadata.name,
+        intent: "object-action-apply",
+        mockOrLive: applyObjectActionMetadata.status,
+        uiVisible: true,
+        expectedDelta: applyObjectActionMetadata.uxIntent.expectedDelta
+      });
+      const nowUtc = currentAuditTimestamp(runtime);
+      const proposalId = input.proposalId ?? mockId(documentSeed2(runtime), `object-action-${input.actionHandle || "missing-handle"}-${input.operation.kind}`);
+      if (!input.actionHandle) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-handle-required",
+          category: "unresolved-target",
+          message: "Object actions require an actionHandle from ai.listObjectActions.",
+          nextStep: "Call ai.listObjectActions for the owning scope and retry with one returned actionHandle.",
+          operation: input.operation.kind
+        });
+      }
+      const target = resolveObjectActionHandle(runtime, documentSeed2(runtime), input.actionHandle);
+      if (!target) {
+        return blockedResult2(input, proposalId, {
+          code: `object-action-handle-not-found:${input.actionHandle}`,
+          category: "unresolved-target",
+          message: "No current object action matches the supplied opaque action handle.",
+          nextStep: "Refresh the scope bundle or call ai.listObjectActions before retrying.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      if (!isSupportedImageTarget(target)) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-image-target-required",
+          category: "blocked-target",
+          message: "The supplied object action handle no longer identifies a mutable image target.",
+          nextStep: "Refresh object actions; chart, OLE, custom XML, opaque, and stale object targets remain refused.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      const mediaId = target.object?.mediaId;
+      if (!mediaId) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-media-id-required",
+          category: "blocked-target",
+          message: "Image object layout mutation requires a mediaId-backed target.",
+          nextStep: "Retry only with an image action handle whose readback includes mediaId.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      const before = runtime.getCanonicalDocument();
+      runtime.dispatch({
+        type: "image.set-layout",
+        mediaId,
+        dimensions: {
+          widthEmu: input.operation.dimensions.widthEmu,
+          heightEmu: input.operation.dimensions.heightEmu
+        },
+        origin: { source: "api", timestamp: nowUtc }
+      });
+      const changed = runtime.getCanonicalDocument() !== before;
+      if (!changed) {
+        return blockedResult2(input, proposalId, {
+          code: `object-action-noop:${input.operation.kind}:${input.actionHandle}`,
+          category: "runtime-noop",
+          message: "The runtime accepted the image target but the object operation produced no document change.",
+          nextStep: "Refresh object actions and verify the image media item still exists before retrying.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      return {
+        proposalId,
+        applied: true,
+        changed: true,
+        actionHandle: input.actionHandle,
+        operation: input.operation.kind,
+        commandReference: {
+          command: "image.set-layout",
+          actorId: input.actorId ?? "v3-ai-api",
+          origin: input.origin ?? "agent",
+          emittedAtUtc: nowUtc
+        },
+        readback: objectReadback(runtime, target),
+        posture: "supported",
+        support: objectActionSupport()
+      };
+    }
+  };
+}
+function isSupportedImageObjectEvidence(entry) {
+  return entry.kind === "object-anchor" && entry.commandFamily === "object" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("image-layout") && isImageKind(entry.object?.objectKind) && typeof entry.object?.mediaId === "string";
+}
+function projectObjectDescriptor(runtime, seed, entry) {
+  return {
+    actionHandle: objectActionHandle(seed, entry.targetKey),
+    objectKind: entry.object?.objectKind ?? "unknown",
+    targetKind: entry.kind,
+    relation: entry.relation,
+    callableOperations: ["set-image-layout"],
+    supportedOperations: ["set-image-layout"],
+    readback: objectReadback(runtime, entry),
+    reason: entry.runtimeCommand.reason
+  };
+}
+function resolveObjectActionHandle(runtime, seed, actionHandle) {
+  return collectEditableTargetRefs(runtime.getCanonicalDocument()).find(
+    (target) => objectActionHandle(seed, target.targetKey) === actionHandle && isSupportedImageTarget(target)
+  ) ?? null;
+}
+function isSupportedImageTarget(target) {
+  return target.kind === "object-anchor" && target.commandFamily === "object" && isImageKind(target.object?.objectKind) && typeof target.object?.mediaId === "string" && target.object.mediaId.length > 0 && onlyObjectActionBlockers(target.posture.blockers, ["unmodeled-target"]);
+}
+function isImageKind(kind) {
+  return kind === "legacy-image" || kind === "picture";
+}
+function onlyObjectActionBlockers(blockers, allowed) {
+  const allowedSet = new Set(allowed);
+  return blockers.every((blocker2) => allowedSet.has(blocker2));
+}
+function objectReadback(runtime, target) {
+  const mediaId = target.object?.mediaId;
+  if (!mediaId) return {};
+  const media = runtime.getCanonicalDocument().media.items[mediaId];
+  return {
+    mediaId,
+    ...media?.widthEmu !== void 0 ? { widthEmu: media.widthEmu } : {},
+    ...media?.heightEmu !== void 0 ? { heightEmu: media.heightEmu } : {}
+  };
+}
+function blockedResult2(input, proposalId, detail) {
+  return {
+    proposalId,
+    applied: false,
+    changed: false,
+    actionHandle: input.actionHandle,
+    operation: input.operation.kind,
+    reason: detail.code,
+    blockers: [detail.code],
+    blockerDetails: [detail]
+  };
+}
+function objectActionSupport() {
+  return {
+    undo: "supported",
+    replay: "supported",
+    exportReopen: "supported",
+    audit: "command-reference"
+  };
+}
+function objectActionHandle(seed, targetKey) {
+  return `object-action:${hashOpaque2(`${seed}::${targetKey}`)}`;
+}
+function documentSeed2(runtime) {
+  const state = runtime.getSessionState();
+  return state.documentId ?? "document";
+}
+function hashOpaque2(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).padStart(7, "0");
+}
+
 // src/api/v3/ai/actions.ts
 function actionMethodMetadata(method, readOrMutate, auditCategory, contextPromptShape, uxIntent) {
   return {
@@ -7268,6 +7478,17 @@ var locateAllMetadata = actionMethodMetadata(
   "Find scope/table-text targets by query; table text matches include readback {text,isEmpty}.",
   { uiVisible: false, expectsUxResponse: "none" }
 );
+var createPlaceholderScopesMetadata = actionMethodMetadata(
+  "createPlaceholderScopes",
+  "mutate",
+  "actions-placeholder-scopes",
+  "Create marker-backed workflow scopes for bracketed placeholder matches in paragraphs, tables, and lists using one bounded regex search.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "scope-created",
+    expectedDelta: "placeholder text ranges become workflow scopes"
+  }
+);
 var rewriteMetadata = actionMethodMetadata(
   "rewrite",
   "mutate",
@@ -7480,6 +7701,7 @@ var ACTION_METHODS = Object.freeze([
   "discover",
   "locate",
   "locateAll",
+  "createPlaceholderScopes",
   "rewrite",
   "rewriteAll",
   "insertText",
@@ -7505,6 +7727,8 @@ var DEFAULT_LOCATE_LIMIT = 20;
 var DEFAULT_REWRITE_ALL_LIMIT = 10;
 var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
 var DEFAULT_PLAN_STEP_LIMIT = 20;
+var DEFAULT_PLACEHOLDER_QUERY = "\\[[^\\[\\]]{1,200}\\]";
+var DEFAULT_PLACEHOLDER_LIMIT = 200;
 function createActionsFamily(runtime) {
   const category = {
     discover(input) {
@@ -7559,6 +7783,9 @@ function createActionsFamily(runtime) {
     locateAll(input) {
       return locateAll(runtime, input);
     },
+    createPlaceholderScopes(input) {
+      return createPlaceholderScopes(runtime, input ?? {});
+    },
     rewrite(input) {
       if (input.text === void 0) {
         return blockedApply(
@@ -8327,6 +8554,169 @@ function locateAll(runtime, input) {
     ...matches.length === 0 ? { blockers: Object.freeze([`actions:locate:not-found:${input.query}`]) } : {}
   };
 }
+function createPlaceholderScopes(runtime, input) {
+  const query = input.query ?? DEFAULT_PLACEHOLDER_QUERY;
+  if (!query) {
+    const detail = blocker(
+      "actions:placeholder-scopes:query-required",
+      "input",
+      "Placeholder scope creation requires a non-empty query.",
+      "Retry with a non-empty query string or omit query to use the bracketed-placeholder default."
+    );
+    return {
+      status: "blocked",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const limit = Math.max(0, input.limit ?? DEFAULT_PLACEHOLDER_LIMIT);
+  let hits;
+  try {
+    hits = runtime.findAllText(query, {
+      regex: input.regex ?? true,
+      matchCase: input.matchCase ?? true,
+      limit
+    });
+  } catch {
+    const detail = blocker(
+      "actions:placeholder-scopes:invalid-query",
+      "input",
+      "The placeholder query could not be compiled or searched.",
+      "Retry with a valid literal query or JavaScript regex pattern."
+    );
+    return {
+      status: "blocked",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  if (hits.length === 0) {
+    return {
+      status: "not-found",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([`actions:placeholder-scopes:not-found:${query}`])
+    };
+  }
+  const surface = runtime.getRenderSnapshot().surface;
+  const orderedHits = hits.filter((hit) => hit.kind === "range").map((hit, originalIndex) => ({
+    hit,
+    originalIndex,
+    text: surface ? textForSurfaceRange(surface.blocks, hit.from, hit.to) : ""
+  })).sort((a, b) => b.hit.from - a.hit.from || b.originalIndex - a.originalIndex);
+  if (orderedHits.length === 0) {
+    const detail = blocker(
+      "actions:placeholder-scopes:no-range-hits",
+      "unsupported",
+      "The placeholder query matched only projections that cannot be converted into workflow ranges.",
+      "Retry with a text query that resolves to concrete document text ranges."
+    );
+    return {
+      status: "blocked",
+      totalHits: hits.length,
+      created: 0,
+      blocked: hits.length,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const compiler = createScopeCompilerService(runtime);
+  const byOriginalIndex = /* @__PURE__ */ new Map();
+  for (const item of orderedHits) {
+    const text = item.text || query;
+    const label = input.labelPrefix === void 0 ? text : `${input.labelPrefix} ${item.originalIndex + 1}`;
+    const result = createScopeFromAnchor(runtime, {
+      anchor: { from: item.hit.from, to: item.hit.to },
+      mode: input.mode ?? "edit",
+      label,
+      ...input.visibility ? { visibility: input.visibility } : {},
+      ...input.guardPolicy ? { guardPolicy: input.guardPolicy } : {},
+      ...input.assoc ? { assoc: input.assoc } : {},
+      ...input.stableRefHint ? { stableRefHint: input.stableRefHint } : {}
+    });
+    if (result.status === "created") {
+      const compiled = compiler.compileScopeById(result.scopeId)?.scope;
+      byOriginalIndex.set(item.originalIndex, {
+        status: "created",
+        text,
+        excerpt: excerpt(text),
+        scopeId: result.scopeId,
+        ...compiled?.handle ? { handle: compiled.handle } : {}
+      });
+      continue;
+    }
+    const detail = blockerWithOwner(
+      `actions:placeholder-scopes:create-refused:${result.reason}`,
+      "blocked",
+      "The placeholder match could not be converted into a workflow scope.",
+      "Refresh the document and retry; if it still refuses, route the target to the workflow/scope writer owner.",
+      "L06"
+    );
+    byOriginalIndex.set(item.originalIndex, {
+      status: "blocked",
+      text,
+      excerpt: excerpt(text),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    });
+  }
+  const scopes = orderedHits.map((item) => byOriginalIndex.get(item.originalIndex)).filter((value) => value !== void 0);
+  const created = scopes.filter((scope) => scope.status === "created").length;
+  const blocked = scopes.length - created;
+  const blockerDetails = scopes.flatMap((scope) => scope.blockerDetails ?? []);
+  return {
+    status: created === scopes.length ? "created" : created > 0 ? "partial" : "blocked",
+    totalHits: hits.length,
+    created,
+    blocked,
+    scopes: Object.freeze(scopes),
+    ...blockerDetails.length > 0 ? {
+      blockers: Object.freeze(blockerDetails.map((detail) => detail.code)),
+      blockerDetails: Object.freeze(blockerDetails)
+    } : {}
+  };
+}
+function textForSurfaceRange(blocks, from, to) {
+  let acc = "";
+  const visit = (items) => {
+    for (const block of items) {
+      if (block.kind === "paragraph") {
+        for (const segment of block.segments) {
+          if (segment.kind !== "text") continue;
+          if (segment.from >= to) return;
+          if (segment.to <= from) continue;
+          acc += segment.text.slice(
+            Math.max(0, from - segment.from),
+            Math.min(segment.text.length, to - segment.from)
+          );
+        }
+        continue;
+      }
+      if (block.kind === "table") {
+        for (const row of block.rows) {
+          for (const cell of row.cells) visit(cell.content);
+        }
+        continue;
+      }
+      if (block.kind === "sdt_block") {
+        visit(block.children);
+      }
+    }
+  };
+  visit(blocks);
+  return acc;
+}
 function validateTemplateTargets(runtime, input) {
   if (!Array.isArray(input.targets) || input.targets.length === 0) {
     const detail = blocker(
@@ -8747,6 +9137,15 @@ function applyRewrite(runtime, target, input) {
     if (!listTextTarget.ok) return blockedApplyFromResolution(listTextTarget);
     return applyEditableTextRewrite(runtime, listTextTarget.target, input);
   }
+  const tableTextTarget = uniqueTableTextActionForScope(runtime, target.handle);
+  if (tableTextTarget.ok && tableTextTarget.action.readback?.text === target.scope.content.text) {
+    return applyTableScopedMarkerRewrite(
+      runtime,
+      target,
+      tableTextTarget.action,
+      input
+    );
+  }
   const rewriteBlocker = scopeRewriteCapabilityBlocker(target.scope);
   if (rewriteBlocker) {
     return blockedApply(
@@ -8879,6 +9278,106 @@ function applyEditableTextRewrite(runtime, target, input) {
     afterReadback
   };
 }
+function applyTableScopedMarkerRewrite(runtime, target, action, input) {
+  const workflowScope = runtime.getScope(target.handle.scopeId);
+  const editableTarget = tableEditableTargetForActionHandle(
+    runtime,
+    action.actionHandle
+  );
+  if (!workflowScope || workflowScope.anchor.kind !== "range" || !editableTarget) {
+    return blockedApply(
+      `actions:rewrite:table-marker-target-unresolved:${target.handle.scopeId}`,
+      "unresolved-target",
+      "The table-contained marker scope could not be joined to a current table text target.",
+      "Refresh placeholder scopes and retry; route persistent failures to L08 table scope target mapping."
+    );
+  }
+  const before = runtime.getCanonicalDocument();
+  try {
+    runtime.dispatch({
+      type: "selection.set",
+      selection: {
+        anchor: workflowScope.anchor.from,
+        head: workflowScope.anchor.to,
+        isCollapsed: workflowScope.anchor.from === workflowScope.anchor.to,
+        activeRange: {
+          kind: "range",
+          from: workflowScope.anchor.from,
+          to: workflowScope.anchor.to,
+          assoc: workflowScope.anchor.assoc ?? { start: -1, end: 1 }
+        }
+      },
+      origin: actionOrigin(runtime, input)
+    });
+    runtime.applyActiveStoryTextCommand({
+      type: "text.insert",
+      text: input.text,
+      editableTarget,
+      origin: actionOrigin(runtime, input)
+    });
+  } catch {
+    return blockedApply(
+      `actions:rewrite:table-marker-command-refused:${target.handle.scopeId}`,
+      "blocked",
+      "The table-contained marker scope could not be rewritten by the runtime text command.",
+      "Retry with an exact table text actionHandle; route repeated failures to L07 table text command support.",
+      [
+        blockerWithOwner(
+          `actions:rewrite:table-marker-command-refused:${target.handle.scopeId}`,
+          "blocked",
+          "The table-contained marker scope could not be rewritten by the runtime text command.",
+          "Retry with an exact table text actionHandle; route repeated failures to L07 table text command support.",
+          "L07 runtime text command support"
+        )
+      ]
+    );
+  }
+  const changed = runtime.getCanonicalDocument() !== before;
+  const paragraph = resolveParagraphTextTarget2(
+    runtime.getCanonicalDocument(),
+    editableTarget
+  );
+  const afterText = paragraph ? collectInlineText3(paragraph.children) : void 0;
+  const afterReadback = afterText === void 0 ? void 0 : { text: afterText, isEmpty: afterText.length === 0 };
+  if (!changed || afterReadback?.text !== input.text) {
+    return {
+      status: "blocked",
+      applied: false,
+      changed,
+      target: summarizeTarget({ kind: "table-text", action }),
+      posture: "suspect-readback",
+      blockers: Object.freeze([
+        `actions:rewrite:table-marker-readback-mismatch:${target.handle.scopeId}`
+      ]),
+      blockerDetails: Object.freeze([
+        blocker(
+          `actions:rewrite:table-marker-readback-mismatch:${target.handle.scopeId}`,
+          "blocked",
+          "The table-contained marker rewrite did not produce the requested exact table-cell readback.",
+          "Treat the mutation as suspect. Re-read the target and export before claiming success."
+        )
+      ]),
+      ...afterReadback ? { afterReadback } : {}
+    };
+  }
+  return {
+    status: "applied",
+    applied: true,
+    changed: true,
+    target: summarizeTarget({
+      kind: "table-text",
+      action: { ...action, readback: afterReadback }
+    }),
+    commandReference: {
+      command: "text.insert",
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    ...action.readback ? { beforeReadback: action.readback } : {},
+    afterReadback
+  };
+}
 function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText, documentMutated) {
   if (!result.applied) return projectApplyResult(result, target);
   const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
@@ -8995,6 +9494,51 @@ function tableTextActionsForScope(runtime, handle) {
   });
   return result.actions.filter((action) => action.family === "table-text");
 }
+function uniqueTableTextActionForScope(runtime, handle) {
+  const actions = tableTextActionsForScope(runtime, handle).filter(
+    (action) => action.readback !== void 0
+  );
+  if (actions.length === 1 && actions[0]) {
+    return { ok: true, action: actions[0] };
+  }
+  if (actions.length === 0) {
+    return {
+      ok: false,
+      blockers: Object.freeze(["actions:rewrite:table-text-target-missing"]),
+      blockerDetails: Object.freeze([
+        blocker(
+          "actions:rewrite:table-text-target-missing",
+          "unsupported",
+          "The scope does not expose a unique command-safe table text target.",
+          "Use a paragraph/list scope, or retry with an exact table text actionHandle returned by ai.actions.locateAll."
+        )
+      ])
+    };
+  }
+  return {
+    ok: false,
+    blockers: Object.freeze(["actions:rewrite:table-text-target-ambiguous"]),
+    blockerDetails: Object.freeze([
+      blocker(
+        "actions:rewrite:table-text-target-ambiguous",
+        "ambiguous-target",
+        "The scope exposes multiple table text targets, so broad rewrite would be ambiguous.",
+        "Retry with the exact table text actionHandle returned by ai.actions.locateAll or ai.listTableActions."
+      )
+    ])
+  };
+}
+function tableEditableTargetForActionHandle(runtime, actionHandle) {
+  for (const target of collectEditableTargetRefs(runtime.getCanonicalDocument())) {
+    if (target.commandFamily !== "text-leaf" || target.table?.operationScope !== "text") {
+      continue;
+    }
+    if (deriveTableActionHandleForTarget(runtime, target.targetKey) === actionHandle) {
+      return target;
+    }
+  }
+  return null;
+}
 function editableTextActionsForScope(runtime, handle) {
   const bundle = createScopeCompilerService(runtime).compileBundleById(
     handle.scopeId,
@@ -10518,6 +11062,7 @@ function createApiV3(handle, opts) {
     ...createStatsFamily(handle),
     ...createOutlineFamily(handle),
     ...createTableActionFamily(handle),
+    ...createObjectActionFamily(handle),
     ...createActionsFamily(handle)
   };
   const runtime = {