@sixb/core 0.1.8 → 0.1.9

package/dist/{chunk-h5vqbfmd.js → chunk-ypbtykv6.js}

@@ -1,75 +1,75 @@
 // @bun
 import {
-  countObjects,
-  executeObjectQuery,
-  executeObjectQueryLinks,
-  existsObjects,
-  facetObjects,
-  preflightObjectQueryLinks,
-  validateObjectFacetRequests,
-  validateObjectQuery,
-  validateObjectQueryWithAdmission
-} from "./chunk-q0k9nc5a.js";
+  MAX_OBJECT_READ_FACETS2,
+  assertObjectReadOutputWithinLimit2,
+  resolveRuntimeAuthorizationForProject,
+  getAuthorizationRef,
+  captureExecutionScope,
+  resolveExecutionScopeAuthorization,
+  AuthorizationError2,
+  isAllowed2,
+  assertAuthorized2,
+  canViewActionRun2
+} from "./chunk-dz5h08xv.js";
 import {
-  ObjectQueryValidationError
-} from "./chunk-rte5sm3z.js";
+  createSixbError2,
+  toSixbFailure2
+} from "./chunk-f4w3yp4f.js";
 import {
-  createPrimitiveExecutionRecord,
-  ensureExecutionRecord,
-  executionRecordInputFromRuntime
-} from "./chunk-k522z7v6.js";
+  ACTION_RUN_FAILURE_CODES2,
+  parseActionRunFailure2
+} from "./chunk-b19g04jk.js";
 import {
-  actionRunParamsEqual,
-  actionSubjectsEqual,
-  isTerminalActionRun
-} from "./chunk-sbzzr4kx.js";
+  ActionRunError2
+} from "./chunk-vsj3mdfj.js";
 import {
-  ACTION_RUN_FAILURE_CODES,
-  parseActionRunFailure
-} from "./chunk-ka3a2ft3.js";
+  isObjectActionDefinition2,
+  normalizeActionParams,
+  validateActionSubject,
+  resolveObjectActionSubject
+} from "./chunk-g00bfdq6.js";
 import {
-  ActionRunError
-} from "./chunk-w1tvjszy.js";
+  actionSubjectsEqual2,
+  actionRunParamsEqual2,
+  isTerminalActionRun2
+} from "./chunk-8vj0rjgs.js";
 import {
-  findPrimitiveParentRequestExecution
-} from "./chunk-j1sbhm7p.js";
+  validateObjectQuery2,
+  validateObjectQueryWithAdmission,
+  executeObjectQuery2,
+  countObjects2,
+  existsObjects2,
+  facetObjects2,
+  validateObjectFacetRequests,
+  preflightObjectQueryLinks,
+  executeObjectQueryLinks2
+} from "./chunk-0w35wavj.js";
 import {
-  reportRunFailure
-} from "./chunk-jq43kdvk.js";
+  reportRunFailure2
+} from "./chunk-7apz6hg4.js";
 import {
-  isObjectActionDefinition,
-  normalizeActionParams,
-  resolveObjectActionSubject,
-  validateActionSubject
-} from "./chunk-4sm0aznx.js";
+  ObjectQueryValidationError2
+} from "./chunk-5hz0fnca.js";
 import {
-  createLinkTokenMap,
-  createPropertyTokenMap
-} from "./chunk-19jp6g9d.js";
+  executionRecordInputFromRuntime,
+  ensureExecutionRecord2,
+  createPrimitiveExecutionRecord
+} from "./chunk-17kfctj6.js";
 import {
-  AuthorizationError,
-  MAX_OBJECT_READ_FACETS,
-  assertAuthorized,
-  assertObjectReadOutputWithinLimit,
-  canViewActionRun,
-  captureExecutionScope,
-  getAuthorizationRef,
-  isAllowed,
-  resolveExecutionScopeAuthorization,
-  resolveRuntimeAuthorizationForProject
-} from "./chunk-p1x242ad.js";
+  findPrimitiveParentRequestExecution
+} from "./chunk-ey1nk510.js";
 import {
-  OntologyNotFoundError,
-  OntologyValidationError,
-  formatUnknownObjectTypeMessage
-} from "./chunk-dktq02ne.js";
+  createPropertyTokenMap2,
+  createLinkTokenMap2
+} from "./chunk-653vwrzr.js";
 import {
-  createSixbError,
-  toSixbFailure
-} from "./chunk-2xns679x.js";
+  OntologyValidationError2,
+  OntologyNotFoundError2,
+  formatUnknownObjectTypeMessage
+} from "./chunk-cqr3acm1.js";
 
 // src/objects/action/errors.ts
-class ActionValidationError extends Error {
+class ActionValidationError2 extends Error {
   name = "ActionValidationError";
   actionId;
   subject;
@@ -82,7 +82,7 @@ class ActionValidationError extends Error {
   }
 }
 
-class ActionRunFailedError extends Error {
+class ActionRunFailedError2 extends Error {
   name = "ActionRunFailedError";
   runId;
   actionId;
@@ -103,7 +103,7 @@ class ActionRunFailedError extends Error {
   }
 }
 
-class ActionRunTimeoutError extends Error {
+class ActionRunTimeoutError2 extends Error {
   name = "ActionRunTimeoutError";
   runId;
   timeoutMs;
@@ -169,7 +169,7 @@ function createAuthorizedOntologyView(input) {
         return unknownObjectType(objectTypeId);
       const primary = objectType.properties.find((property) => property.primary);
       if (!primary) {
-        throw new OntologyValidationError(`[Sixb] Object type '${objectTypeId}' does not expose its primary property in this execution scope.`);
+        throw new OntologyValidationError2(`[Sixb] Object type '${objectTypeId}' does not expose its primary property in this execution scope.`);
       }
       return release(primary.id);
     },
@@ -279,8 +279,8 @@ function projectObjectType(input) {
   };
   const withTokens = {
     ...projected,
-    p: createPropertyTokenMap(projected),
-    l: createLinkTokenMap(projected)
+    p: createPropertyTokenMap2(projected),
+    l: createLinkTokenMap2(projected)
   };
   return deepFreeze(withTokens);
 }
@@ -434,7 +434,7 @@ function deepFreeze(value, seen = new Set) {
   return Object.freeze(value);
 }
 function unknownObjectType(objectTypeId) {
-  throw new OntologyNotFoundError(formatUnknownObjectTypeMessage(objectTypeId));
+  throw new OntologyNotFoundError2(formatUnknownObjectTypeMessage(objectTypeId));
 }
 
 // src/objects/query/selected-read-admission.ts
@@ -457,18 +457,18 @@ function createSelectedObjectQueryAdmission(scope) {
   const admission = {
     empty: () => emptyState,
     source: (input) => {
-      const selections = input.result.objectTypeIds.flatMap((objectTypeId2) => selectionsByType.get(objectTypeId2) ?? []);
+      const selections = input.result.objectTypeIds.flatMap((objectTypeId) => selectionsByType.get(objectTypeId) ?? []);
       const state = selectedState(selections);
       if (input.kind === "refs") {
-        const missingType = [...new Set(input.refs?.map((ref) => ref.objectTypeId) ?? [])].sort().find((objectTypeId2) => !selectionsByType.has(objectTypeId2));
+        const missingType = [...new Set(input.refs?.map((ref) => ref.objectTypeId) ?? [])].sort().find((objectTypeId) => !selectionsByType.has(objectTypeId));
         if (missingType) {
-          return denied(state, new AuthorizationError(`view:object:${missingType}`, `[Sixb] Delegated query cannot reference object type '${missingType}' at '${input.path}': the selected object scope does not contain that type.`));
+          return denied(state, new AuthorizationError2(`view:object:${missingType}`, `[Sixb] Delegated query cannot reference object type '${missingType}' at '${input.path}': the selected object scope does not contain that type.`));
         }
       }
       if (state.selections.length > 0)
         return { state };
       const objectTypeId = input.objectTypeId ?? input.result.objectTypeIds[0] ?? "unknown";
-      return denied(state, new AuthorizationError(`view:object:${objectTypeId}`, `[Sixb] Delegated query cannot start from object type '${objectTypeId}' at '${input.path}': the selected object scope does not contain that type.`));
+      return denied(state, new AuthorizationError2(`view:object:${objectTypeId}`, `[Sixb] Delegated query cannot start from object type '${objectTypeId}' at '${input.path}': the selected object scope does not contain that type.`));
     },
     property: (input) => propertyDenial(asSelectedState(input.state), input.propertyId, input.objectTypeId, input.use, input.path, propertiesBySelection),
     edge: (input) => {
@@ -534,11 +534,11 @@ function propertyDenial(state, propertyId, objectTypeId, use, path, propertiesBy
   if (!missing)
     return;
   const objectTypeIds = [...new Set(candidates.map((selection) => selection.objectTypeId))].sort();
-  return new AuthorizationError(`view:object:${objectTypeIds.join(",")}:property:${propertyId}`, `[Sixb] Delegated query cannot use property '${propertyId}' for ${use} at '${path}': it is not selected on every matching read-scope path (missing on ${formatSelection(missing)}).`);
+  return new AuthorizationError2(`view:object:${objectTypeIds.join(",")}:property:${propertyId}`, `[Sixb] Delegated query cannot use property '${propertyId}' for ${use} at '${path}': it is not selected on every matching read-scope path (missing on ${formatSelection(missing)}).`);
 }
 function edgeDenial(state, linkId, direction, sourceObjectTypeId, use, path) {
   const source = sourceObjectTypeId ? `:${sourceObjectTypeId}` : "";
-  return new AuthorizationError(`view:link:${direction}${source}:${linkId}`, `[Sixb] Delegated query cannot use ${direction} link '${linkId}' for ${use} from ${formatState(state)} at '${path}': that exact read-scope path is not selected.`);
+  return new AuthorizationError2(`view:link:${direction}${source}:${linkId}`, `[Sixb] Delegated query cannot use ${direction} link '${linkId}' for ${use} from ${formatState(state)} at '${path}': that exact read-scope path is not selected.`);
 }
 function formatState(state) {
   if (state.selections.length === 0)
@@ -666,7 +666,7 @@ class AuthorizedObjectReaderImpl {
       ontology: reader.#ontology,
       selection: ontologySelectionForAuthority(authority, reader.#ontology),
       ...authority.type === "delegated" ? {
-        assertOutputWithinLimit: (value) => assertObjectReadOutputWithinLimit(value, authority.objectRead.limits)
+        assertOutputWithinLimit: (value) => assertObjectReadOutputWithinLimit2(value, authority.objectRead.limits)
       } : {}
     });
     return reader.#ontologyView;
@@ -791,7 +791,7 @@ class AuthorizedObjectReaderImpl {
     const query = snapshotAuthoredQuery(input.query);
     const includeTotal = snapshotReadValue(input.includeTotal);
     const executionQuery = this.#admitDelegatedQuery(query)?.query ?? query;
-    return detachReadResult(await executeObjectQuery({
+    return detachReadResult(await executeObjectQuery2({
       query: executionQuery,
       ...includeTotal === undefined ? {} : { includeTotal },
       projectId: this.#runtime.projectId
@@ -819,7 +819,7 @@ class AuthorizedObjectReaderImpl {
       });
       executionQuery = admitted.query;
     }
-    const result = detachReadResult(await executeObjectQueryLinks({ query: executionQuery, ...request, projectId: this.#runtime.projectId }, this.#queryExecutorOptions()));
+    const result = detachReadResult(await executeObjectQueryLinks2({ query: executionQuery, ...request, projectId: this.#runtime.projectId }, this.#queryExecutorOptions()));
     if (result.objects.some((row) => !this.#isObjectTypeViewable(row.objectTypeId)) || result.links.some((link) => !this.#isLinkViewable(link))) {
       throw new Error("[Sixb] Object storage returned a link page outside its authorized scope.");
     }
@@ -828,12 +828,12 @@ class AuthorizedObjectReaderImpl {
   async count(input) {
     const query = snapshotAuthoredQuery(input.query);
     const executionQuery = this.#admitDelegatedQuery(query)?.query ?? query;
-    return detachReadResult(await countObjects({ query: executionQuery, projectId: this.#runtime.projectId }, this.#queryExecutorOptions()));
+    return detachReadResult(await countObjects2({ query: executionQuery, projectId: this.#runtime.projectId }, this.#queryExecutorOptions()));
   }
   async exists(input) {
     const query = snapshotAuthoredQuery(input.query);
     const executionQuery = this.#admitDelegatedQuery(query)?.query ?? query;
-    return detachReadResult(await existsObjects({ query: executionQuery, projectId: this.#runtime.projectId }, this.#queryExecutorOptions()));
+    return detachReadResult(await existsObjects2({ query: executionQuery, projectId: this.#runtime.projectId }, this.#queryExecutorOptions()));
   }
   async facet(input) {
     const query = snapshotAuthoredQuery(input.query);
@@ -842,7 +842,7 @@ class AuthorizedObjectReaderImpl {
     let executionFacets = facets;
     const admission = this.#delegatedQueryAdmission;
     if (admission) {
-      const validated = validateObjectQuery(query, { ontology: this.#ontology });
+      const validated = validateObjectQuery2(query, { ontology: this.#ontology });
       const normalizedFacets = validateObjectFacetRequests(facets, validated.result.objectTypeIds, {
         ontology: this.#ontology
       });
@@ -858,7 +858,7 @@ class AuthorizedObjectReaderImpl {
       executionQuery = admitted.query;
       executionFacets = normalizedFacets;
     }
-    return detachReadResult(await facetObjects({
+    return detachReadResult(await facetObjects2({
       query: executionQuery,
       facets: executionFacets,
       projectId: this.#runtime.projectId
@@ -867,7 +867,7 @@ class AuthorizedObjectReaderImpl {
   assertVisibleOutputWithinLimit(value) {
     if (this.#authority.type !== "delegated")
       return;
-    assertObjectReadOutputWithinLimit(value, this.#authority.objectRead.limits);
+    assertObjectReadOutputWithinLimit2(value, this.#authority.objectRead.limits);
   }
   admitTelemetryHistoryRead(input) {
     return admitTelemetryHistoryReadWorkload(input, this.#authority.type === "delegated");
@@ -893,12 +893,12 @@ class AuthorizedObjectReaderImpl {
       for (const objectTypeId of new Set(objectTypeIds)) {
         if (this.#delegatedObjectTypeIds?.has(objectTypeId))
           continue;
-        throw new AuthorizationError(`delegated:object.view:${objectTypeId}`, `[Sixb] Delegated authorization does not select object type '${objectTypeId}'.`);
+        throw new AuthorizationError2(`delegated:object.view:${objectTypeId}`, `[Sixb] Delegated authorization does not select object type '${objectTypeId}'.`);
       }
       return;
     }
     for (const objectTypeId of new Set(objectTypeIds)) {
-      assertAuthorized(this.#runtime, { kind: "object.view", objectTypeId });
+      assertAuthorized2(this.#runtime, { kind: "object.view", objectTypeId });
     }
   }
   #resolveListObjectTypes(requested) {
@@ -918,7 +918,7 @@ class AuthorizedObjectReaderImpl {
     if (this.#authority.type === "delegated") {
       return this.#delegatedObjectTypeIds?.has(objectTypeId) ?? false;
     }
-    return isAllowed(this.#runtime.authorization, { kind: "object.view", objectTypeId });
+    return isAllowed2(this.#runtime.authorization, { kind: "object.view", objectTypeId });
   }
   #isLinkViewable(link) {
     if (!this.#isObjectTypeViewable(link.sourceTypeId) || !this.#isObjectTypeViewable(link.targetTypeId)) {
@@ -974,7 +974,7 @@ function ontologySelectionForAuthority(authority, ontology) {
     case "principal":
       return {
         kind: "types",
-        objectTypeIds: ontology.listObjectTypes().filter((objectType) => isAllowed(authority.context, {
+        objectTypeIds: ontology.listObjectTypes().filter((objectType) => isAllowed2(authority.context, {
           kind: "object.view",
           objectTypeId: objectType.id
         })).map((objectType) => objectType.id)
@@ -994,7 +994,7 @@ function snapshotReadValue(value) {
 }
 function snapshotFacetRequests(facets) {
   if (!Array.isArray(facets)) {
-    throw new ObjectQueryValidationError([
+    throw new ObjectQueryValidationError2([
       {
         path: "$.facets",
         code: "invalid_facets",
@@ -1003,12 +1003,12 @@ function snapshotFacetRequests(facets) {
     ]);
   }
   const length = facets.length;
-  if (!Number.isSafeInteger(length) || length > MAX_OBJECT_READ_FACETS) {
-    throw new ObjectQueryValidationError([
+  if (!Number.isSafeInteger(length) || length > MAX_OBJECT_READ_FACETS2) {
+    throw new ObjectQueryValidationError2([
       {
         path: "$.facets",
         code: "too_many_facets",
-        message: `facets must include at most ${MAX_OBJECT_READ_FACETS} facet requests`
+        message: `facets must include at most ${MAX_OBJECT_READ_FACETS2} facet requests`
       }
     ]);
   }
@@ -1023,9 +1023,9 @@ function snapshotAuthoredQuery(query) {
   try {
     return structuredClone(query);
   } catch (error) {
-    if (error instanceof ObjectQueryValidationError)
+    if (error instanceof ObjectQueryValidationError2)
       throw error;
-    throw new ObjectQueryValidationError([
+    throw new ObjectQueryValidationError2([
       {
         path: "$",
         code: "query_not_cloneable",
@@ -1061,14 +1061,14 @@ async function admitDelegatedObjectAction(input) {
     if (!visible)
       throw denied2(action.id, subject);
   } catch (error) {
-    if (error instanceof AuthorizationError)
+    if (error instanceof AuthorizationError2)
       throw denied2(action.id, subject);
     throw error;
   }
 }
 function denied2(actionId, subject) {
   const target = subject.kind === "object" ? `${subject.objectTypeId}:${subject.primaryId}` : "global";
-  return new AuthorizationError(`apply:action:${actionId}:${target}`, `[Sixb] Delegated authority cannot apply Action '${actionId}' to '${target}'.`);
+  return new AuthorizationError2(`apply:action:${actionId}:${target}`, `[Sixb] Delegated authority cannot apply Action '${actionId}' to '${target}'.`);
 }
 
 // src/actions/run-authorization.ts
@@ -1103,7 +1103,7 @@ import { randomUUID } from "crypto";
 function createActionRunId(runId) {
   if (runId !== undefined) {
     if (!runId.trim()) {
-      throw new OntologyValidationError("[Sixb] Action run id must not be empty");
+      throw new OntologyValidationError2("[Sixb] Action run id must not be empty");
     }
     return runId;
   }
@@ -1163,7 +1163,7 @@ async function persistActionRun(input, request) {
       return { publish: true, run, execution, queuedAt, created: true };
     }, { isolation: "serializable" });
   } catch (error) {
-    if (!(error instanceof ActionRunError))
+    if (!(error instanceof ActionRunError2))
       throw error;
     const raced = await actionRuns.getById({ projectId: input.projectId, id: request.runId });
     if (!raced)
@@ -1182,7 +1182,7 @@ async function reuseActionRun(input, existing) {
     id: existing.executionId
   });
   if (!execution) {
-    throw new ActionRunError(`[Sixb] Execution '${existing.executionId}' for Action run '${existing.id}' was not found.`);
+    throw new ActionRunError2(`[Sixb] Execution '${existing.executionId}' for Action run '${existing.id}' was not found.`);
   }
   const queuedAt = new Date;
   const run = await requireActionRunStorage(input.storage).queue({
@@ -1248,7 +1248,7 @@ async function failActionRunPublication(input, run, error) {
     finishedAt: failedAt,
     error: failure
   });
-  reportRunFailure(input.errorReporterHost, error, {
+  reportRunFailure2(input.errorReporterHost, error, {
     projectId: input.projectId,
     runKind: "action",
     run: { runId: run.id, actionId: run.actionId },
@@ -1257,13 +1257,13 @@ async function failActionRunPublication(input, run, error) {
 }
 function requireActionRunStorage(storage) {
   if (!storage.actionRuns) {
-    throw new ActionRunError("[Sixb] Action run storage is not configured.");
+    throw new ActionRunError2("[Sixb] Action run storage is not configured.");
   }
   return storage.actionRuns;
 }
 function assertExistingRunMatchesRequest(existing, request) {
-  if (existing.actionId !== request.actionId || !actionSubjectsEqual(existing.subject, request.subject) || !actionRunParamsEqual(existing.params, request.params)) {
-    throw new ActionRunError(`[Sixb] Action run '${existing.id}' already exists with a different request payload.`);
+  if (existing.actionId !== request.actionId || !actionSubjectsEqual2(existing.subject, request.subject) || !actionRunParamsEqual2(existing.params, request.params)) {
+    throw new ActionRunError2(`[Sixb] Action run '${existing.id}' already exists with a different request payload.`);
   }
 }
 function isRetryableEnqueueFailure(record) {
@@ -1277,12 +1277,12 @@ function existingActionRunResult(existing) {
   };
 }
 function toActionRunFailure(error, run, at) {
-  const enqueueError = createSixbError("queue.enqueue_failed", `[Sixb] Could not enqueue Action run '${run.id}'.`, {
+  const enqueueError = createSixbError2("queue.enqueue_failed", `[Sixb] Could not enqueue Action run '${run.id}'.`, {
     cause: error,
     details: { actionId: run.actionId, runId: run.id, phase: "enqueue" }
   });
-  return parseActionRunFailure(toSixbFailure(enqueueError, {
-    allowedCodes: ACTION_RUN_FAILURE_CODES,
+  return parseActionRunFailure2(toSixbFailure2(enqueueError, {
+    allowedCodes: ACTION_RUN_FAILURE_CODES2,
     at
   }), "enqueue");
 }
@@ -1298,11 +1298,11 @@ function clearTimer(timer) {
 function getActionDefinition(runtime, actionId) {
   const action = runtime.actionRegistry.getById(actionId);
   if (!action) {
-    throw new OntologyValidationError(`Unknown action '${actionId}'`);
+    throw new OntologyValidationError2(`Unknown action '${actionId}'`);
   }
   return action;
 }
-async function requestAction(runtime, execution, input) {
+async function requestAction3(runtime, execution, input) {
   const projectId = runtime.projectId;
   const runtimeAuthorization = runtime.runtimeAuthorization;
   const objectReader = runtime.objectReader;
@@ -1330,15 +1330,15 @@ async function requestAction(runtime, execution, input) {
       subject: delegatedSubject
     });
   } else {
-    assertAuthorized({ projectId, runtimeAuthorization }, { kind: "action.apply", actionId });
+    assertAuthorized2({ projectId, runtimeAuthorization }, { kind: "action.apply", actionId });
   }
   if (authorization.type !== "delegated" && action.binding.kind === "object") {
-    assertAuthorized({ projectId, runtimeAuthorization }, { kind: "object.view", objectTypeId: action.binding.objectType.id });
+    assertAuthorized2({ projectId, runtimeAuthorization }, { kind: "object.view", objectTypeId: action.binding.objectType.id });
   }
   validateActionSubject(action, subject);
   let pathPrefix = action.id;
   let objectType = null;
-  if (isObjectActionDefinition(action)) {
+  if (isObjectActionDefinition2(action)) {
     objectType = resolveObjectActionSubject({ runtime, action, subject });
     pathPrefix = `${objectType.id}.${action.id}`;
   }
@@ -1362,12 +1362,12 @@ async function requestAction(runtime, execution, input) {
           run: existing,
           grantId: authorization.delegation.grantId
         })) {
-          throw new AuthorizationError(`apply:action:${actionId}`, "[Sixb] Delegated authority cannot reuse this Action run.");
+          throw new AuthorizationError2(`apply:action:${actionId}`, "[Sixb] Delegated authority cannot reuse this Action run.");
         }
       }
     } : {},
     createExecution: async (executionId, runId) => {
-      const caller = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
+      const caller = await ensureExecutionRecord2(runtime.storage.executions, executionRecordInputFromRuntime({
         execution,
         runtimeAuthorization
       }));
@@ -1391,20 +1391,20 @@ function snapshotActionRequest(input) {
     ...runId === undefined ? {} : { runId }
   });
 }
-async function requestActionAndWait(runtime, execution, input) {
+async function requestActionAndWait2(runtime, execution, input) {
   const runId = createActionRunId(input.runId);
-  await requestAction(runtime, execution, {
+  await requestAction3(runtime, execution, {
     ...input,
     runId
   });
   await input.onRequested?.(runId);
-  return waitForActionRun(runtime, {
+  return waitForActionRun2(runtime, {
     runId,
     timeoutMs: input.timeoutMs,
     signal: input.signal
   });
 }
-async function waitForActionRun(runtime, input) {
+async function waitForActionRun2(runtime, input) {
   const projectId = runtime.projectId;
   const runtimeAuthorization = runtime.runtimeAuthorization;
   const request = {
@@ -1417,7 +1417,7 @@ async function waitForActionRun(runtime, input) {
     runtimeAuthorization
   });
   if (authorization.type === "denied") {
-    throw new AuthorizationError("runtime:unbound", "[Sixb] Protected operations require registered runtime authorization for this project.");
+    throw new AuthorizationError2("runtime:unbound", "[Sixb] Protected operations require registered runtime authorization for this project.");
   }
   if (authorization.type === "delegated")
     getAuthorizationRef(runtimeAuthorization);
@@ -1474,15 +1474,15 @@ async function waitForActionRun(runtime, input) {
           projectId,
           id: request.runId
         });
-        const visible = record && (authorization.type === "unrestricted" || authorization.type === "principal" && canViewActionRun(authorization.context, record) || authorization.type === "delegated" && await canDelegationAccessActionRun({
+        const visible = record && (authorization.type === "unrestricted" || authorization.type === "principal" && canViewActionRun2(authorization.context, record) || authorization.type === "delegated" && await canDelegationAccessActionRun({
           storage: runtime.storage,
           projectId,
           authority: authorization,
           run: record
         }));
-        if (visible && isTerminalActionRun(record)) {
+        if (visible && isTerminalActionRun2(record)) {
           if (authorization.type === "delegated") {
-            assertObjectReadOutputWithinLimit(record, authorization.objectRead.limits);
+            assertObjectReadOutputWithinLimit2(record, authorization.objectRead.limits);
           }
           cleanup();
           resolve(record);
@@ -1499,7 +1499,7 @@ async function waitForActionRun(runtime, input) {
       rejectWith(signal?.reason ?? new Error("aborted"));
     };
     timer = setTimeout(() => {
-      rejectWith(new ActionRunTimeoutError({ runId: request.runId, timeoutMs }));
+      rejectWith(new ActionRunTimeoutError2({ runId: request.runId, timeoutMs }));
     }, Math.max(0, timeoutMs - (Date.now() - startedAt)));
     if (signal) {
       signal.addEventListener("abort", onAbort, { once: true });
@@ -1527,11 +1527,11 @@ async function waitForActionRun(runtime, input) {
 function requireActionRunStorage2(runtime) {
   const actionRuns = runtime.storage.actionRuns;
   if (!actionRuns) {
-    throw new ActionRunError("[Sixb] Action run storage is not configured.");
+    throw new ActionRunError2("[Sixb] Action run storage is not configured.");
   }
   return actionRuns;
 }
 
-export { ActionValidationError, ActionRunFailedError, ActionRunTimeoutError, createAuthorizedObjectReader, assertAuthorizedObjectReaderBinding, getAuthorizedOntologyView, canDelegationAccessActionRun, requestAction, requestActionAndWait, waitForActionRun };
+export { ActionValidationError2, ActionRunFailedError2, ActionRunTimeoutError2, createAuthorizedObjectReader, assertAuthorizedObjectReaderBinding, getAuthorizedOntologyView, canDelegationAccessActionRun, requestAction3, requestActionAndWait2, waitForActionRun2 };
 
-//# debugId=FFB8DCF8ECEF803364756E2164756E21
+//# debugId=FFE2BFEFAAE60BAE64756E2164756E21