@sixb/core 0.1.6 → 0.1.8

package/dist/{chunk-f83ka50g.js → chunk-p1x242ad.js}

@@ -1,13 +1,24 @@
 // @bun
+import {
+  compileSelectedObjectReadScope
+} from "./chunk-r8jrnexe.js";
 import {
   resolveSemanticType
-} from "./chunk-rnshztfq.js";
+} from "./chunk-h0k55pc7.js";
 import {
   createSixbError
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 import {
   compareStrings
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
+
+// src/execution/authorization.ts
+import { isDeepStrictEqual } from "util";
+
+// src/agents/identity.ts
+function agentServiceAccountId(actorId) {
+  return `svc_agent_${actorId}`;
+}
 
 // src/authorization/grant-kinds.ts
 var GRANT_KINDS = {
@@ -42,6 +53,11 @@ var GRANT_KINDS = {
     subject: "action",
     fix: "Add it to 'actions/' or pass it to createSixb({ actions })."
   },
+  "share:share": {
+    universeKey: "shareIds",
+    subject: "share",
+    fix: "Add it to 'shares/' or pass it to createSixb({ shares })."
+  },
   "run:workflow": {
     universeKey: "workflowIds",
     subject: "workflow",
@@ -58,22 +74,33 @@ var GRANT_KINDS = {
     fix: "Add it to 'pipelines/' or pass it to createSixb({ pipelines })."
   },
   "run:agent": {
-    universeKey: "agentIds",
+    singleton: true,
     subject: "agent",
-    fix: "Add it to 'agents/' or pass it to createSixb({ agents })."
+    fix: "Configure models.language and use the exported agent reference in can.run(agent)."
   },
   "observe:logs": {
     universeKey: "observableIds",
     subject: "observability surface",
     fix: 'Use can.observe("logs").'
   },
+  "observe:aiUsage": {
+    universeKey: "observableIds",
+    subject: "observability surface",
+    fix: "Use can.observe(agent.usage)."
+  },
   "manage:connector": {
     universeKey: "connectorIds",
     subject: "connector",
     fix: "Add it to 'connectors/' or pass it to createSixb({ connectors })."
+  },
+  "manage:aiUsage": {
+    universeKey: "manageableIds",
+    subject: "management surface",
+    fix: "Use can.manage(agent.usage)."
   }
 };
 var GRANT_KIND_KEYS = Object.keys(GRANT_KINDS);
+var TARGETED_GRANT_KIND_KEYS = GRANT_KIND_KEYS.filter((kind) => kind !== "run:agent");
 function grantKindOf(grant) {
   switch (grant.capability) {
     case "access":
@@ -86,20 +113,273 @@ function grantKindOf(grant) {
       return "append:telemetry";
     case "apply":
       return "apply:action";
+    case "share":
+      return "share:share";
     case "run":
       return `run:${grant.target}`;
     case "observe":
-      return "observe:logs";
+      return `observe:${grant.target}`;
     case "manage":
-      return "manage:connector";
+      return `manage:${grant.target}`;
   }
 }
 function emptyGrantSets() {
-  const sets = {};
-  for (const kind of GRANT_KIND_KEYS) {
-    sets[kind] = new Set;
+  return {
+    "access:application": new Set,
+    "view:object": new Set,
+    "view:dataset": new Set,
+    "edit:object": new Set,
+    "append:telemetry": new Set,
+    "apply:action": new Set,
+    "share:share": new Set,
+    "run:workflow": new Set,
+    "run:sync": new Set,
+    "run:pipeline": new Set,
+    "run:agent": false,
+    "observe:logs": new Set,
+    "observe:aiUsage": new Set,
+    "manage:connector": new Set,
+    "manage:aiUsage": new Set
+  };
+}
+
+// src/storage/objects/execution-limits.ts
+var MAX_OBJECT_READ_FACETS = 16;
+var MAX_OUTPUT_JSON_DEPTH = 64;
+
+class ObjectReadLimitExceededError extends Error {
+  metric;
+  limit;
+  name = "ObjectReadLimitExceededError";
+  code = "object_read_limit_exceeded";
+  constructor(metric, limit) {
+    super(`[Sixb] Object read exceeded its ${metric} limit (${limit}).`);
+    this.metric = metric;
+    this.limit = limit;
   }
-  return sets;
+}
+function snapshotObjectReadExecutionLimits(limits) {
+  if (typeof limits !== "object" || limits === null) {
+    throw new Error("[Sixb] Object read execution limits must be provided.");
+  }
+  return Object.freeze({
+    maxTraversalFacts: positiveSafeInteger(limits.maxTraversalFacts, "maxTraversalFacts"),
+    maxOutputJsonBytes: positiveSafeInteger(limits.maxOutputJsonBytes, "maxOutputJsonBytes")
+  });
+}
+function assertObjectReadFacetCount(count) {
+  if (!Number.isSafeInteger(count) || count < 0 || count > MAX_OBJECT_READ_FACETS) {
+    throw new Error(`[Sixb] An object read supports between 0 and ${MAX_OBJECT_READ_FACETS} facets.`);
+  }
+}
+function assertObjectReadOutputWithinLimit(value, limits) {
+  const fail = () => {
+    throw new ObjectReadLimitExceededError("outputJsonBytes", limits.maxOutputJsonBytes);
+  };
+  const stack = [];
+  let bytes = 0;
+  const addBytes = (count) => {
+    bytes += count;
+    if (bytes > limits.maxOutputJsonBytes)
+      fail();
+  };
+  const addPrimitiveBytes = (primitive) => {
+    switch (typeof primitive) {
+      case "string":
+        addBytes(jsonStringUtf8Length(primitive));
+        break;
+      case "number":
+        addBytes(Number.isFinite(primitive) ? Object.is(primitive, -0) ? 1 : String(primitive).length : 4);
+        break;
+      case "boolean":
+        addBytes(primitive ? 4 : 5);
+        break;
+    }
+  };
+  try {
+    JSON.stringify(value, function(key, current) {
+      const parent = isObject(this) ? this : undefined;
+      let parentFrameIndex = -1;
+      if (parent) {
+        for (let index = stack.length - 1;index >= 0; index -= 1) {
+          if (stack[index]?.value === parent) {
+            parentFrameIndex = index;
+            break;
+          }
+        }
+      }
+      const isRoot = parentFrameIndex === -1;
+      if (isRoot) {
+        stack.length = 0;
+      } else {
+        stack.length = parentFrameIndex + 1;
+      }
+      const parentFrame = isRoot ? undefined : stack[parentFrameIndex];
+      const parentIsArray = Array.isArray(parent);
+      const unsupported = current === undefined || typeof current === "function" || typeof current === "symbol";
+      if (!isRoot) {
+        if (!parentIsArray && unsupported)
+          return current;
+        if (!parentFrame)
+          return fail();
+        if (parentFrame.serializedChildren > 0)
+          addBytes(1);
+        parentFrame.serializedChildren += 1;
+        if (!parentIsArray)
+          addBytes(jsonStringUtf8Length(key) + 1);
+      } else if (unsupported) {
+        return current;
+      }
+      if (parentIsArray && unsupported) {
+        addBytes(4);
+        return current;
+      }
+      if (isObject(current)) {
+        const special = inspectJsonSpecialObject(current);
+        switch (special.kind) {
+          case "primitive":
+            addPrimitiveBytes(special.value);
+            return special.value;
+          case "bigint":
+            throw new TypeError("BigInt is not JSON serializable");
+          case "raw":
+            addBytes(rawJsonUtf8Length(special.value));
+            return current;
+          case "ordinary":
+            break;
+        }
+      }
+      switch (typeof current) {
+        case "string":
+          addPrimitiveBytes(current);
+          break;
+        case "number":
+          addPrimitiveBytes(current);
+          break;
+        case "boolean":
+          addPrimitiveBytes(current);
+          break;
+        case "bigint":
+          throw new TypeError("BigInt is not JSON serializable");
+        case "object":
+          if (current === null) {
+            addBytes(4);
+            break;
+          }
+          if (stack.some((frame) => frame.value === current)) {
+            throw new TypeError("Cyclic object value");
+          }
+          if (stack.length + 1 > MAX_OUTPUT_JSON_DEPTH)
+            fail();
+          addBytes(2);
+          stack.push({ value: current, serializedChildren: 0 });
+          break;
+      }
+      return current;
+    });
+  } catch (error) {
+    if (error instanceof ObjectReadLimitExceededError)
+      throw error;
+    if (error instanceof RangeError || error instanceof TypeError)
+      fail();
+    throw error;
+  }
+}
+var jsonWithRawJson = JSON;
+var isRawJson = jsonWithRawJson.isRawJSON?.bind(jsonWithRawJson);
+var booleanValueOf = bindValueOf(Boolean.prototype.valueOf);
+var numberValueOf = bindValueOf(Number.prototype.valueOf);
+var stringValueOf = bindValueOf(String.prototype.valueOf);
+var bigintValueOf = bindValueOf(BigInt.prototype.valueOf);
+var toStringValue = String;
+function inspectJsonSpecialObject(value) {
+  if (isRawJson?.(value)) {
+    const raw = value.rawJSON;
+    if (typeof raw !== "string")
+      return { kind: "ordinary" };
+    return { kind: "raw", value: raw };
+  }
+  const boolean = unbox(value, booleanValueOf);
+  if (boolean.matched)
+    return { kind: "primitive", value: boolean.value };
+  const number = unbox(value, numberValueOf);
+  if (number.matched)
+    return { kind: "primitive", value: +value };
+  const string = unbox(value, stringValueOf);
+  if (string.matched)
+    return { kind: "primitive", value: toStringValue(value) };
+  if (unbox(value, bigintValueOf).matched)
+    return { kind: "bigint" };
+  return { kind: "ordinary" };
+}
+function bindValueOf(unboxer) {
+  return Function.prototype.call.bind(unboxer);
+}
+function unbox(value, unboxer) {
+  try {
+    return { matched: true, value: unboxer(value) };
+  } catch {
+    return { matched: false };
+  }
+}
+function rawJsonUtf8Length(value) {
+  let bytes = 0;
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 127) {
+      bytes += 1;
+    } else if (code <= 2047) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index += 1;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function jsonStringUtf8Length(value) {
+  let bytes = 2;
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92) {
+      bytes += 2;
+    } else if (code <= 31) {
+      bytes += code === 8 || code === 9 || code === 10 || code === 12 || code === 13 ? 2 : 6;
+    } else if (code <= 127) {
+      bytes += 1;
+    } else if (code <= 2047) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index += 1;
+      } else {
+        bytes += 6;
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      bytes += 6;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function positiveSafeInteger(value, name) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`[Sixb] ${name} must be a positive safe integer.`);
+  }
+  return value;
 }
 
 // src/execution/types.ts
@@ -124,24 +404,32 @@ function isRuntimeAuthorizationCapability(value) {
 
 // src/execution/authorization.ts
 var registeredAuthorizations = new WeakMap;
+var MAX_DELEGATED_ACTION_APPLY_TARGETS = 4096;
+var MAX_DELEGATED_ACTION_IDENTIFIER_CHARACTERS = 1e6;
 function createPrincipalRuntimeAuthorization(input) {
+  if (input.execution.executor.type !== "request") {
+    throw new Error("[Sixb] Principal runtime authorization requires a request execution.");
+  }
   return createRegisteredPrincipalAuthorization(input);
 }
 function createAgentRuntimeAuthorization(input) {
-  if (input.context.principal.type !== "serviceAccount") {
-    throw new Error("[Sixb] Agent execution authority must belong to a service account.");
-  }
-  assertNonEmpty(input.executionId, "Execution id");
-  assertNonEmpty(input.agentId, "Agent id");
-  assertNonEmpty(input.runId, "Agent run id");
-  return createRegisteredPrincipalAuthorization(input, {
-    type: "agent",
-    executionId: input.executionId,
-    agentId: input.agentId,
-    runId: input.runId
+  if (input.execution.executor.type !== "agent") {
+    throw new Error("[Sixb] Agent runtime authorization requires an Agent execution.");
+  }
+  if (input.authority.type === "principal") {
+    return createRegisteredPrincipalAuthorization({
+      execution: input.execution,
+      context: input.authority.context,
+      ...input.authority.credential === undefined ? {} : { credential: input.authority.credential }
+    });
+  }
+  return register(input.execution, {
+    type: "unrestricted",
+    projectId: input.execution.projectId,
+    ref: Object.freeze({ type: "disabled" })
   });
 }
-function createRegisteredPrincipalAuthorization(input, executionBinding) {
+function createRegisteredPrincipalAuthorization(input) {
   const context = snapshotAuthorizationContext(input.context);
   const credential = input.credential ? snapshotCredential(input.credential) : undefined;
   assertCredentialMatchesContext(context, credential);
@@ -150,22 +438,46 @@ function createRegisteredPrincipalAuthorization(input, executionBinding) {
     principal: context.principal,
     ...credential === undefined ? {} : { credential }
   });
-  return register({
+  return register(input.execution, {
     type: "principal",
-    projectId: input.projectId,
+    projectId: input.execution.projectId,
     context,
-    ref,
-    ...executionBinding === undefined ? {} : { executionBinding: Object.freeze({ ...executionBinding }) }
+    ref
+  });
+}
+function createDisabledRuntimeAuthorization(execution) {
+  return register(execution, {
+    type: "unrestricted",
+    projectId: execution.projectId,
+    ref: Object.freeze({ type: "disabled" })
   });
 }
-function createDisabledRuntimeAuthorization(projectId) {
-  return register({ type: "unrestricted", projectId, ref: Object.freeze({ type: "disabled" }) });
+function createDelegatedRuntimeAuthorization(input) {
+  const execution = input.execution;
+  const objectReadInput = input.objectRead;
+  const actionApplyInput = input.actionApply;
+  const delegationInput = input.delegation;
+  const delegation = delegationInput === undefined ? undefined : snapshotSharedDelegation(delegationInput);
+  if (execution.executor.type !== "request" || execution.requestedBy !== undefined) {
+    throw new Error("[Sixb] Delegated runtime authorization requires a request execution without a principal.");
+  }
+  const objectRead = Object.freeze({
+    scope: compileSelectedObjectReadScope(objectReadInput.selection),
+    limits: snapshotObjectReadExecutionLimits(objectReadInput.limits)
+  });
+  return register(execution, {
+    type: "delegated",
+    projectId: execution.projectId,
+    objectRead,
+    actionApply: snapshotDelegatedActionApply(actionApplyInput ?? []),
+    ...delegation === undefined ? {} : { delegation }
+  });
 }
 function createTrustedPrimitiveRuntimeAuthorization(input) {
   const primitive = snapshotTrustedPrimitive(input.primitive);
-  return register({
+  return register(input.execution, {
     type: "unrestricted",
-    projectId: input.projectId,
+    projectId: input.execution.projectId,
     ref: Object.freeze({ type: "trustedPrimitive", primitive })
   });
 }
@@ -173,15 +485,38 @@ function resolveRuntimeAuthorization(authorization) {
   if (!isRuntimeAuthorizationCapability(authorization)) {
     return { type: "denied" };
   }
-  return registeredAuthorizations.get(authorization) ?? { type: "denied" };
+  return registeredAuthorizations.get(authorization)?.resolved ?? { type: "denied" };
+}
+function resolveRuntimeAuthorizationForProject(input) {
+  const resolved = resolveRuntimeAuthorization(input.runtimeAuthorization);
+  if (resolved.type === "denied" || typeof input.projectId !== "string" || resolved.projectId !== input.projectId) {
+    return { type: "denied" };
+  }
+  return resolved;
 }
 function getAuthorizationRef(authorization) {
   const resolved = resolveRuntimeAuthorization(authorization);
   if (resolved.type === "denied") {
     throw new Error("[Sixb] Runtime authorization is not a registered Core capability.");
   }
+  if (resolved.type === "delegated") {
+    if (resolved.delegation) {
+      return { type: "delegated", delegation: { ...resolved.delegation } };
+    }
+    throw new Error("[Sixb] Delegated runtime authorization cannot cross a durable execution boundary.");
+  }
   return cloneAuthorizationRef(resolved.ref);
 }
+function snapshotSharedDelegation(input) {
+  const kind = input.kind;
+  const grantId = input.grantId;
+  const sessionId = input.sessionId;
+  if (kind !== "share")
+    throw new Error("[Sixb] Unknown delegated authority provenance.");
+  assertNonEmpty(grantId, "Share grant id");
+  assertNonEmpty(sessionId, "Share session id");
+  return Object.freeze({ kind, grantId, sessionId });
+}
 function assertExecutionScopeProject(projectId, scope) {
   assertNonEmpty(projectId, "Project id");
   if (scope.execution.projectId !== projectId) {
@@ -207,42 +542,71 @@ function assertExecutionScopeProject(projectId, scope) {
     });
   }
 }
+function captureExecutionScope(scope) {
+  const execution = scope.execution;
+  const authorization = scope.authorization;
+  return Object.freeze({ execution, authorization });
+}
 function resolveExecutionScopeAuthorization(projectId, scope) {
-  assertExecutionScopeProject(projectId, scope);
-  const resolved = resolveRuntimeAuthorization(scope.authorization);
+  const capturedScope = captureExecutionScope(scope);
+  assertExecutionScopeProject(projectId, capturedScope);
+  const resolved = resolveRuntimeAuthorization(capturedScope.authorization);
   if (resolved.type === "denied") {
-    throw createSixbError("internal.unexpected", "[Sixb] Execution scope carries unregistered runtime authorization.", { details: { executionId: scope.execution.id, projectId } });
+    throw createSixbError("internal.unexpected", "[Sixb] Execution scope carries unregistered runtime authorization.", { details: { executionId: capturedScope.execution.id, projectId } });
   }
-  const { execution } = scope;
+  const registration = registeredAuthorizations.get(capturedScope.authorization);
+  if (!registration || !executionMatchesBinding(registration.execution, capturedScope.execution)) {
+    throw invalidExecutionAuthority(capturedScope.execution.id, "authority is bound to different execution provenance");
+  }
+  assertResolvedAuthorizationMatchesExecution(resolved, capturedScope.execution);
+  return resolved;
+}
+function assertResolvedAuthorizationMatchesExecution(resolved, execution) {
   switch (execution.executor.type) {
     case "request":
       if (execution.source.type !== "http" || execution.source.requestId !== execution.executor.requestId) {
         throw invalidExecutionAuthority(execution.id, "request source does not match its executor");
       }
-      if (resolved.ref.type === "principal") {
-        if (resolved.type !== "principal" || resolved.executionBinding !== undefined || !principalsEqual(execution.requestedBy, resolved.ref.principal)) {
+      if (resolved.type === "principal") {
+        if (!principalsEqual(execution.requestedBy, resolved.ref.principal)) {
           throw invalidExecutionAuthority(execution.id, "request authority does not match its requested-by principal");
         }
-        return resolved;
+        return;
+      }
+      if (resolved.type === "unrestricted" && resolved.ref.type === "disabled" && execution.requestedBy === undefined) {
+        return;
       }
-      if (resolved.ref.type === "disabled" && execution.requestedBy === undefined)
-        return resolved;
-      throw invalidExecutionAuthority(execution.id, "request execution requires principal or explicitly disabled authority");
+      if (resolved.type === "delegated" && execution.requestedBy === undefined)
+        return;
+      throw invalidExecutionAuthority(execution.id, "request execution requires principal, delegated, or explicitly disabled authority");
     case "primitive":
-      if (resolved.ref.type !== "trustedPrimitive" || resolved.ref.primitive.kind !== execution.executor.kind || resolved.ref.primitive.id !== execution.executor.id || resolved.ref.primitive.runId !== execution.executor.runId) {
+      if (resolved.type !== "unrestricted" || resolved.ref.type !== "trustedPrimitive" || resolved.ref.primitive.kind !== execution.executor.kind || resolved.ref.primitive.id !== execution.executor.id || resolved.ref.primitive.runId !== execution.executor.runId) {
         throw invalidExecutionAuthority(execution.id, "trusted primitive authority does not match its executor");
       }
-      return resolved;
+      return;
     case "agent":
-      if (resolved.type !== "principal" || resolved.ref.type !== "principal" || resolved.ref.principal.type !== "serviceAccount" || resolved.ref.credential !== undefined || resolved.executionBinding?.type !== "agent" || resolved.executionBinding.executionId !== execution.id || resolved.executionBinding.agentId !== execution.executor.agentId || resolved.executionBinding.runId !== execution.executor.runId) {
-        throw invalidExecutionAuthority(execution.id, "agent authority does not match its execution binding");
+      if (execution.source.type !== "execution") {
+        throw invalidExecutionAuthority(execution.id, "agent execution requires an execution source");
+      }
+      if (resolved.type === "principal" && resolved.ref.type === "principal") {
+        if (resolved.ref.principal.type === "serviceAccount") {
+          const actorId = execution.executor.actorId;
+          if (actorId === undefined || resolved.ref.principal.id !== agentServiceAccountId(actorId) || resolved.ref.credential !== undefined) {
+            throw invalidExecutionAuthority(execution.id, "agent authority must reference its managed service account");
+          }
+        } else if (resolved.ref.credential === undefined) {
+          throw invalidExecutionAuthority(execution.id, "inherited user agent authority requires a credential");
+        }
+        return;
       }
-      return resolved;
+      if (resolved.type === "unrestricted" && resolved.ref.type === "disabled")
+        return;
+      throw invalidExecutionAuthority(execution.id, "agent authority must be principal or explicitly disabled");
     case "kernel":
-      if (resolved.ref.type !== "kernel" || execution.requestedBy !== undefined || resolved.ref.operation.type !== execution.executor.operation.type || resolved.ref.operation.recoveryId !== execution.executor.operation.recoveryId) {
+      if (resolved.type !== "unrestricted" || resolved.ref.type !== "kernel" || execution.requestedBy !== undefined || resolved.ref.operation.type !== execution.executor.operation.type || resolved.ref.operation.recoveryId !== execution.executor.operation.recoveryId) {
         throw invalidExecutionAuthority(execution.id, "kernel authority does not match its executor");
       }
-      return resolved;
+      return;
   }
 }
 function principalsEqual(left, right) {
@@ -251,19 +615,99 @@ function principalsEqual(left, right) {
 function invalidExecutionAuthority(executionId, reason) {
   return createSixbError("internal.unexpected", `[Sixb] Execution '${executionId}' is incompatible with its authority: ${reason}.`, { details: { executionId, reason } });
 }
-function register(input) {
+function register(execution, input) {
   assertNonEmpty(input.projectId, "Authorization project id");
+  const executionBinding = snapshotExecutionContext(execution);
+  if (input.projectId !== executionBinding.projectId) {
+    throw new Error(`[Sixb] Runtime authorization belongs to project '${input.projectId}', not execution project '${executionBinding.projectId}'.`);
+  }
+  assertResolvedAuthorizationMatchesExecution(input, executionBinding);
   const authorization = createRuntimeAuthorizationCapability();
-  registeredAuthorizations.set(authorization, Object.freeze(input));
+  registeredAuthorizations.set(authorization, Object.freeze({ resolved: Object.freeze(input), execution: executionBinding }));
   return authorization;
 }
+function executionMatchesBinding(binding, execution) {
+  try {
+    return isDeepStrictEqual(binding, snapshotExecutionContext(execution));
+  } catch {
+    return false;
+  }
+}
+function snapshotExecutionContext(execution) {
+  assertNonEmpty(execution.id, "Execution id");
+  assertNonEmpty(execution.projectId, "Execution project id");
+  assertNonEmpty(execution.correlationId, "Execution correlation id");
+  return Object.freeze({
+    id: execution.id,
+    projectId: execution.projectId,
+    ...execution.requestedBy === undefined ? {} : { requestedBy: snapshotAuthorizablePrincipal(execution.requestedBy) },
+    executor: snapshotExecutionExecutor(execution.executor),
+    source: snapshotExecutionSource(execution.source),
+    correlationId: execution.correlationId
+  });
+}
+function snapshotExecutionExecutor(executor) {
+  switch (executor.type) {
+    case "request":
+      assertNonEmpty(executor.requestId, "Execution request id");
+      return Object.freeze({ type: "request", requestId: executor.requestId });
+    case "primitive": {
+      const primitive = snapshotTrustedPrimitive(executor);
+      return Object.freeze({ type: "primitive", ...primitive });
+    }
+    case "agent":
+      if (executor.actorId !== undefined)
+        assertNonEmpty(executor.actorId, "Execution Agent actor id");
+      assertNonEmpty(executor.runId, "Execution Agent run id");
+      return Object.freeze({
+        type: "agent",
+        ...executor.actorId === undefined ? {} : { actorId: executor.actorId },
+        runId: executor.runId
+      });
+    case "kernel":
+      return Object.freeze({
+        type: "kernel",
+        operation: snapshotKernelOperation(executor.operation)
+      });
+  }
+  throw new Error(`[Sixb] Unknown execution executor type '${String(executor.type)}'.`);
+}
+function snapshotExecutionSource(source) {
+  switch (source.type) {
+    case "http":
+      assertNonEmpty(source.requestId, "Execution source request id");
+      return Object.freeze({ type: "http", requestId: source.requestId });
+    case "webhook":
+      assertNonEmpty(source.deliveryId, "Execution source delivery id");
+      return Object.freeze({ type: "webhook", deliveryId: source.deliveryId });
+    case "schedule":
+    case "event":
+      assertNonEmpty(source.eventId, "Execution source event id");
+      return Object.freeze({ type: source.type, eventId: source.eventId });
+    case "datasetVersion":
+      assertNonEmpty(source.datasetId, "Execution source dataset id");
+      assertNonEmpty(source.versionId, "Execution source dataset version id");
+      return Object.freeze({
+        type: "datasetVersion",
+        datasetId: source.datasetId,
+        versionId: source.versionId
+      });
+    case "execution":
+      assertNonEmpty(source.executionId, "Execution source execution id");
+      return Object.freeze({ type: "execution", executionId: source.executionId });
+  }
+  throw new Error(`[Sixb] Unknown execution source type '${String(source.type)}'.`);
+}
 function snapshotAuthorizationContext(context) {
   const principal = snapshotAuthorizablePrincipal(context.principal);
-  const grants = emptyGrantSets();
-  for (const kind of GRANT_KIND_KEYS) {
-    grants[kind] = new Set(context.grants[kind]);
+  const grants = {};
+  for (const kind of TARGETED_GRANT_KIND_KEYS) {
+    grants[kind] = new ImmutableGrantSet(context.grants[kind]);
   }
-  const frozenGrants = Object.freeze(grants);
+  const frozenGrants = Object.freeze({
+    ...grants,
+    "run:agent": context.grants["run:agent"]
+  });
   return Object.freeze({
     principal,
     ...context.sessionId === undefined ? {} : { sessionId: context.sessionId },
@@ -272,6 +716,51 @@ function snapshotAuthorizationContext(context) {
     grants: frozenGrants
   });
 }
+
+class ImmutableGrantSet {
+  #values;
+  [Symbol.toStringTag] = "Set";
+  constructor(values) {
+    this.#values = new Set(values);
+    Object.freeze(this);
+  }
+  get size() {
+    return this.#values.size;
+  }
+  has(value) {
+    return this.#values.has(value);
+  }
+  entries() {
+    return this.#values.entries();
+  }
+  keys() {
+    return this.#values.keys();
+  }
+  values() {
+    return this.#values.values();
+  }
+  [Symbol.iterator]() {
+    return this.#values[Symbol.iterator]();
+  }
+  forEach(callback, thisArg) {
+    for (const value of this.#values) {
+      callback.call(thisArg, value, value, this);
+    }
+  }
+  add(_value) {
+    throw immutableGrantSetMutation();
+  }
+  delete(_value) {
+    throw immutableGrantSetMutation();
+  }
+  clear() {
+    throw immutableGrantSetMutation();
+  }
+}
+Object.freeze(ImmutableGrantSet.prototype);
+function immutableGrantSetMutation() {
+  return new Error("[Sixb] Runtime authorization grants are immutable.");
+}
 function snapshotAuthorizablePrincipal(principal) {
   if (principal.type !== "user" && principal.type !== "serviceAccount") {
     throw new Error(`[Sixb] Principal type '${principal.type}' cannot hold runtime authorization.`);
@@ -306,6 +795,56 @@ function snapshotTrustedPrimitive(primitive) {
   assertNonEmpty(primitive.runId, "Trusted primitive run id");
   return Object.freeze({ kind: primitive.kind, id: primitive.id, runId: primitive.runId });
 }
+function snapshotKernelOperation(operation) {
+  if (operation.type !== "ontology.recover") {
+    throw new Error(`[Sixb] Unknown kernel operation '${operation.type}'.`);
+  }
+  assertNonEmpty(operation.recoveryId, "Kernel recovery id");
+  return Object.freeze({ type: operation.type, recoveryId: operation.recoveryId });
+}
+function snapshotDelegatedActionApply(input) {
+  if (!Array.isArray(input)) {
+    throw new Error("[Sixb] Delegated Action targets must be an array.");
+  }
+  const targetCount = input.length;
+  if (targetCount > MAX_DELEGATED_ACTION_APPLY_TARGETS) {
+    throw new Error(`[Sixb] Delegated authority exceeds the maximum of ${MAX_DELEGATED_ACTION_APPLY_TARGETS} Action targets.`);
+  }
+  let identifierCharacters = 0;
+  const targets = [];
+  for (let index = 0;index < targetCount; index += 1) {
+    const authoredTarget = input[index];
+    if (!isRecord(authoredTarget)) {
+      throw new Error(`[Sixb] Delegated Action target ${index} must be an object.`);
+    }
+    const authoredActionId = authoredTarget.actionId;
+    const authoredSubject = authoredTarget.subject;
+    if (!isRecord(authoredSubject)) {
+      throw new Error(`[Sixb] Delegated Action target ${index} subject must be an ObjectRef.`);
+    }
+    const actionId = delegatedActionIdentifier(authoredActionId, `Delegated Action target ${index} action id`);
+    const objectTypeId = delegatedActionIdentifier(authoredSubject.objectTypeId, `Delegated Action target ${index} subject object type id`);
+    const primaryId = delegatedActionIdentifier(authoredSubject.primaryId, `Delegated Action target ${index} subject primary id`);
+    identifierCharacters += actionId.length + objectTypeId.length + primaryId.length;
+    if (identifierCharacters > MAX_DELEGATED_ACTION_IDENTIFIER_CHARACTERS) {
+      throw new Error(`[Sixb] Delegated authority exceeds the maximum of ${MAX_DELEGATED_ACTION_IDENTIFIER_CHARACTERS} Action identifier characters.`);
+    }
+    targets.push(Object.freeze({
+      actionId,
+      subject: Object.freeze({ objectTypeId, primaryId })
+    }));
+  }
+  return Object.freeze(targets);
+}
+function delegatedActionIdentifier(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`[Sixb] ${label} must not be empty.`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function cloneAuthorizationRef(ref) {
   switch (ref.type) {
     case "principal":
@@ -316,6 +855,8 @@ function cloneAuthorizationRef(ref) {
       };
     case "trustedPrimitive":
       return { type: "trustedPrimitive", primitive: { ...ref.primitive } };
+    case "delegated":
+      return { type: "delegated", delegation: { ...ref.delegation } };
     case "kernel":
       return { type: "kernel", operation: { ...ref.operation } };
     case "disabled":
@@ -356,6 +897,8 @@ function atomsFor(request) {
       return [{ kind: "append:telemetry", id: request.objectTypeId }];
     case "action.apply":
       return [{ kind: "apply:action", id: request.actionId }];
+    case "share.manage":
+      return [{ kind: "share:share", id: request.shareId }];
     case "workflow.run":
       return [{ kind: "run:workflow", id: request.workflowId }];
     case "sync.run":
@@ -363,9 +906,13 @@ function atomsFor(request) {
     case "pipeline.run":
       return [{ kind: "run:pipeline", id: request.pipelineId }];
     case "agent.run":
-      return [{ kind: "run:agent", id: request.agentId }];
+      return [{ kind: "run:agent" }];
     case "logs.observe":
       return [{ kind: "observe:logs", id: "logs" }];
+    case "aiUsage.observe":
+      return [{ kind: "observe:aiUsage", id: "aiUsage" }];
+    case "aiUsage.manage":
+      return [{ kind: "manage:aiUsage", id: "aiUsage" }];
     case "connector.manage":
       return [{ kind: "manage:connector", id: request.connectorId }];
     case "object.query":
@@ -373,11 +920,16 @@ function atomsFor(request) {
   }
 }
 function atomKey(atom) {
-  if (atom.kind === "observe:logs")
+  if (atom.kind === "run:agent")
+    return atom.kind;
+  if (atom.kind === "observe:logs" || atom.kind === "observe:aiUsage" || atom.kind === "manage:aiUsage") {
     return atom.kind;
+  }
   return `${atom.kind}:${atom.id}`;
 }
 function holds(grants, atom) {
+  if (atom.kind === "run:agent")
+    return grants[atom.kind];
   return grants[atom.kind].has(atom.id);
 }
 function evaluate(authorization, request) {
@@ -391,6 +943,9 @@ function isAllowed(authorization, request) {
 }
 function assertAuthorized(runtime, request) {
   const resolved = assertRuntimeAuthorizationBound(runtime);
+  if (resolved.type === "delegated") {
+    throw new AuthorizationError(`delegated:${request.kind}`, `[Sixb] Operation '${request.kind}' is not covered by delegated authorization.`);
+  }
   const authorization = resolved.type === "principal" ? resolved.context : undefined;
   const decision = evaluate(authorization, request);
   if (decision.allowed) {
@@ -398,8 +953,14 @@ function assertAuthorized(runtime, request) {
   }
   throw new AuthorizationError(decision.missing[0] ?? request.kind, deniedMessage(authorization, request));
 }
+function isRuntimeAllowed(runtime, request) {
+  const authority = resolveRuntimeAuthorizationForProject(runtime);
+  if (authority.type === "denied" || authority.type === "delegated")
+    return false;
+  return authority.type === "unrestricted" || isAllowed(authority.context, request);
+}
 function assertRuntimeAuthorizationBound(runtime) {
-  const resolved = resolveRuntimeAuthorization(runtime.runtimeAuthorization);
+  const resolved = resolveRuntimeAuthorizationForProject(runtime);
   if (resolved.type === "denied") {
     throw new AuthorizationError("runtime:unbound", "[Sixb] Protected operations require a registered execution scope.");
   }
@@ -423,13 +984,14 @@ function assertPrivileged(runtime, operation) {
   throw new AuthorizationError(`privileged:${operation}`, `[Sixb] Operation '${operation}' is not covered by scoped authorization grants.`);
 }
 function assertProviderAccess(runtime, execution, operation) {
-  const resolved = assertRuntimeAuthorizationBound(runtime);
+  const resolved = resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
   if (resolved.type === "unrestricted") {
     return;
   }
-  const binding = resolved.executionBinding;
-  const executor = execution.executor;
-  if (binding?.type === "agent" && executor.type === "agent" && binding.executionId === execution.id && binding.agentId === executor.agentId && binding.runId === executor.runId) {
+  if (execution.executor.type === "agent") {
     return;
   }
   throw new AuthorizationError(`privileged:${operation}`, `[Sixb] Operation '${operation}' is not covered by scoped authorization grants.`);
@@ -449,6 +1011,8 @@ function deniedMessage(authorization, request) {
       return `[Sixb] Principal '${principalId}' is not allowed to append telemetry for object type '${request.objectTypeId}'.`;
     case "action.apply":
       return `[Sixb] Principal '${principalId}' is not allowed to apply action '${request.actionId}'.`;
+    case "share.manage":
+      return `[Sixb] Principal '${principalId}' is not allowed to manage Share '${request.shareId}'.`;
     case "workflow.run":
       return `[Sixb] Principal '${principalId}' is not allowed to run workflow '${request.workflowId}'.`;
     case "sync.run":
@@ -456,9 +1020,13 @@ function deniedMessage(authorization, request) {
     case "pipeline.run":
       return `[Sixb] Principal '${principalId}' is not allowed to run pipeline '${request.pipelineId}'.`;
     case "agent.run":
-      return `[Sixb] Principal '${principalId}' is not allowed to run agent '${request.agentId}'.`;
+      return `[Sixb] Principal '${principalId}' is not allowed to run the project Agent.`;
     case "logs.observe":
       return `[Sixb] Principal '${principalId}' is not allowed to observe project logs.`;
+    case "aiUsage.observe":
+      return `[Sixb] Principal '${principalId}' is not allowed to observe project AI usage.`;
+    case "aiUsage.manage":
+      return `[Sixb] Principal '${principalId}' is not allowed to manage project AI usage limits.`;
     case "connector.manage":
       return `[Sixb] Principal '${principalId}' is not allowed to manage connector '${request.connectorId}'.`;
     case "object.query": {
@@ -534,6 +1102,10 @@ function canViewEvent(authorization, event) {
 function resolveRoleGrants(role, universe) {
   const grants = emptyGrantSets();
   for (const grant of role.grants) {
+    if (grant.capability === "run" && grant.target === "agent") {
+      grants["run:agent"] = true;
+      continue;
+    }
     const kind = grantKindOf(grant);
     const spec = GRANT_KINDS[kind];
     expandSelection(grant.selection, universe[spec.universeKey], grants[kind], spec.expandsSubtypes ? universe.getSubTypes : undefined);
@@ -568,7 +1140,10 @@ function resolveAuthorizationContext(input) {
       continue;
     }
     roleIds.push(role.id);
-    for (const kind of GRANT_KIND_KEYS) {
+    if (role.grants["run:agent"]) {
+      grants["run:agent"] = true;
+    }
+    for (const kind of TARGETED_GRANT_KIND_KEYS) {
       for (const id of role.grants[kind]) {
         grants[kind].add(id);
       }
@@ -968,7 +1543,7 @@ function assertProjectionDataset(dataset) {
   }
   assertNonEmpty2(dataset.id, "dataset id");
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function lowerForeignKeyMapping(mapping) {
@@ -981,7 +1556,7 @@ function lowerForeignKeyMapping(mapping) {
   return lowered;
 }
 function isForeignKeyDescriptor(value) {
-  return isRecord(value) && typeof value.linkId === "string";
+  return isRecord2(value) && typeof value.linkId === "string";
 }
 function defineProjection(id, target) {
   if ("link" in target)
@@ -1134,7 +1709,7 @@ function lowerTelemetryPropertiesPointMapping(objectType, mapping) {
   if (mapping.properties === undefined) {
     throw new ProjectionValidationError("Telemetry projection point mapping requires properties.");
   }
-  if (!isRecord(mapping.properties)) {
+  if (!isRecord2(mapping.properties)) {
     throw new ProjectionValidationError("Telemetry projection point mapping properties must be an object.");
   }
   assertNonEmpty2(mapping.objectId, "objectId field");
@@ -1162,7 +1737,7 @@ function lowerTelemetryPropertyMapping(propertyId, input) {
     assertNonEmpty2(input, `property '${propertyId}' value field`);
     return { valueField: input };
   }
-  if (!isRecord(input)) {
+  if (!isRecord2(input)) {
     throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' must map a value column or value/unit columns.`);
   }
   const allowedKeys = new Set(["value", "unit"]);
@@ -1231,33 +1806,33 @@ function buildLinkProjection(id, linkToken) {
   };
 }
 function isObjectProjectionDefinition(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return false;
-  return value._tag === "ObjectProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && isRecord(value.properties) && isRecord(value.links) && isSourceEditConflictResolution(value.conflictResolution);
+  return value._tag === "ObjectProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && isRecord2(value.properties) && isRecord2(value.links) && isSourceEditConflictResolution(value.conflictResolution);
 }
 function isSourceEditConflictResolution(value) {
   if (value === undefined)
     return true;
-  if (!isRecord(value) || typeof value.strategy !== "string")
+  if (!isRecord2(value) || typeof value.strategy !== "string")
     return false;
   if (value.strategy === "editsWin")
     return value.sourceTimestamp === undefined;
   return value.strategy === "mostRecent" && typeof value.sourceTimestamp === "string";
 }
 function isLinkProjectionDefinition(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return false;
   return value._tag === "LinkProjectionDefinition" && typeof value.id === "string" && typeof value.linkId === "string" && typeof value.sourceObjectTypeId === "string" && typeof value.targetObjectTypeId === "string" && typeof value.datasetId === "string" && typeof value.sourceField === "string" && typeof value.targetField === "string";
 }
 function isTelemetryProjectionDefinition(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return false;
   return value._tag === "TelemetryProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && typeof value.objectIdField === "string" && typeof value.atField === "string" && isTelemetryProjectionProperties(value.properties);
 }
 function isTelemetryProjectionProperties(value) {
-  if (!isRecord(value) || Object.keys(value).length === 0)
+  if (!isRecord2(value) || Object.keys(value).length === 0)
     return false;
-  return Object.values(value).every((mapping) => isRecord(mapping) && typeof mapping.valueField === "string" && (mapping.unitField === undefined || typeof mapping.unitField === "string"));
+  return Object.values(value).every((mapping) => isRecord2(mapping) && typeof mapping.valueField === "string" && (mapping.unitField === undefined || typeof mapping.unitField === "string"));
 }
 function isProjectionDefinition(value) {
   return isObjectProjectionDefinition(value) || isLinkProjectionDefinition(value) || isTelemetryProjectionDefinition(value);
@@ -1307,6 +1882,6 @@ function canViewProjection(authorization, projection) {
 function emptyGrantIndex() {
   return emptyGrantSets();
 }
-export { ProjectionValidationError, computeProjectionOwnership, validateProjectionOwnership, validateTelemetryProjectionFieldMapping, validateProjectionsAtStartup, defineProjection, fromForeignKey, isObjectProjectionDefinition, isLinkProjectionDefinition, isTelemetryProjectionDefinition, isProjectionDefinition, projectionTargetOf, GRANT_KINDS, grantKindOf, createPrincipalRuntimeAuthorization, createAgentRuntimeAuthorization, createDisabledRuntimeAuthorization, createTrustedPrimitiveRuntimeAuthorization, getAuthorizationRef, resolveExecutionScopeAuthorization, AuthorizationError, evaluate, isAllowed, assertAuthorized, assertCanEdit, assertCanAppendTelemetry, assertCanManageConnector, assertPrivileged, assertProviderAccess, isApplicationAccessControlled, canAccessApplication, canViewEvent, resolveRoleGrants, resolveAuthorizationContext, canViewActionRun, canViewWorkflowRun, canViewWorkflowIntervention, canViewPipelineRun, canViewProjectionRun, canViewProjection, emptyGrantIndex };
+export { ProjectionValidationError, computeProjectionOwnership, validateProjectionOwnership, validateTelemetryProjectionFieldMapping, validateProjectionsAtStartup, defineProjection, fromForeignKey, isObjectProjectionDefinition, isLinkProjectionDefinition, isTelemetryProjectionDefinition, isProjectionDefinition, projectionTargetOf, agentServiceAccountId, GRANT_KINDS, grantKindOf, MAX_OBJECT_READ_FACETS, ObjectReadLimitExceededError, snapshotObjectReadExecutionLimits, assertObjectReadFacetCount, assertObjectReadOutputWithinLimit, createPrincipalRuntimeAuthorization, createAgentRuntimeAuthorization, createDisabledRuntimeAuthorization, createDelegatedRuntimeAuthorization, createTrustedPrimitiveRuntimeAuthorization, resolveRuntimeAuthorizationForProject, getAuthorizationRef, captureExecutionScope, resolveExecutionScopeAuthorization, AuthorizationError, evaluate, isAllowed, assertAuthorized, isRuntimeAllowed, assertRuntimeAuthorizationBound, assertCanEdit, assertCanAppendTelemetry, assertCanManageConnector, assertPrivileged, assertProviderAccess, isApplicationAccessControlled, canAccessApplication, canViewEvent, resolveRoleGrants, resolveAuthorizationContext, canViewActionRun, canViewWorkflowRun, canViewWorkflowIntervention, canViewPipelineRun, canViewProjectionRun, canViewProjection, emptyGrantIndex };
 
-//# debugId=48D20BF42F9CD3F464756E2164756E21
+//# debugId=57388FDEBF4490DF64756E2164756E21