@sixb/core 0.1.20 → 0.1.22

package/dist/chunk-2626mh4m.js

@@ -0,0 +1,693 @@
+// @bun
+import {
+  getAuthorizationRef,
+  AuthorizationError2,
+  isAllowed2,
+  assertAuthorized2,
+  isRuntimeAllowed2,
+  canViewActionRun2,
+  canViewWorkflowRun2
+} from "./chunk-yc9ners4.js";
+import {
+  ACTIVITY_MIN_IDLE_TIMEOUT_MS,
+  ACTIVITY_MAX_VISIT_MS2
+} from "./chunk-fe8zwt8b.js";
+import {
+  objectBatchKey2
+} from "./chunk-ezne9wc9.js";
+import {
+  readerClearance
+} from "./chunk-7z5p905k.js";
+import {
+  executionRecordInputFromRuntime,
+  ensureExecutionRecord2
+} from "./chunk-hyesv9dv.js";
+import {
+  requireAccountingCapabilities,
+  createAiModelCallLimitController2,
+  AiModelCallRecorder2,
+  enqueueAiModelCallRecovery2
+} from "./chunk-fp2kq35z.js";
+import {
+  findPrimitiveParentRequestExecution
+} from "./chunk-ey1nk510.js";
+
+// src/runtime/ontology-mutations.ts
+var ontologyMutationRuntimeKey = Symbol("sixb.ontologyMutationRuntime");
+function registerOntologyMutationRuntime2(owner, runtime) {
+  const registered = owner[ontologyMutationRuntimeKey];
+  if (registered && registered !== runtime) {
+    throw new Error("[Sixb] Ontology mutation runtime is already registered for this owner.");
+  }
+  Object.defineProperty(owner, ontologyMutationRuntimeKey, {
+    configurable: false,
+    enumerable: true,
+    value: runtime,
+    writable: false
+  });
+}
+function getOntologyMutationRuntime2(owner) {
+  const runtime = owner[ontologyMutationRuntimeKey];
+  if (runtime)
+    return runtime;
+  throw new Error("[Sixb] Ontology mutation runtime is not registered for this runtime context.");
+}
+function shareOntologyMutationRuntime2(source, target) {
+  registerOntologyMutationRuntime2(target, getOntologyMutationRuntime2(source));
+}
+function createOntologyMutationRuntime2(input) {
+  const applied = (work) => work.finally(() => notifyWithoutAffecting(input.onProjectionApplied));
+  const runtime = {
+    getProjectionSource: (source) => input.materializer.projections.getActive(source),
+    commitEdits: (command) => commitAndNotify(() => input.materializer.edits.commit(command), input.notifyCommittedFacts),
+    replaceProjection: (command) => applied(commitAndNotify(() => input.materializer.projections.replace(command), input.notifyCommittedFacts)),
+    finishProjection: (command) => applied(input.materializer.projections.finishRun(command)),
+    appendTelemetry: (command) => commitAndNotify(() => input.materializer.telemetry.append(command), input.notifyCommittedFacts)
+  };
+  return Object.freeze(runtime);
+}
+async function commitAndNotify(commit, notify) {
+  const result = await commit();
+  if (result.eventCount > 0)
+    notifyWithoutAffectingCommit(notify);
+  return result;
+}
+function notifyWithoutAffectingCommit(notify) {
+  try {
+    notify();
+  } catch (error) {
+    console.error("[Sixb] Failed to wake the ontology outbox dispatcher:", error);
+  }
+}
+function notifyWithoutAffecting(notify) {
+  try {
+    notify?.();
+  } catch (error) {
+    console.error("[Sixb] Failed to report an applied projection:", error);
+  }
+}
+
+// src/activity/device.ts
+var BROWSERS = [
+  [/\bEdg(?:e|A|iOS)?\//, "Edge"],
+  [/\b(?:OPR|Opera)\//, "Opera"],
+  [/\bSamsungBrowser\//, "Samsung Internet"],
+  [/\b(?:Firefox|FxiOS)\//, "Firefox"],
+  [/\b(?:Chrome|Chromium|CriOS|HeadlessChrome)\//, "Chrome"],
+  [/\bVersion\/[\d.]+.*\bSafari\//, "Safari"]
+];
+var SYSTEMS = [
+  [/\bWindows\b/, "Windows"],
+  [/\biPad\b/, "iPadOS"],
+  [/\b(?:iPhone|iPod)\b/, "iOS"],
+  [/\bAndroid\b/, "Android"],
+  [/\bCrOS\b/, "ChromeOS"],
+  [/\bMac OS X\b|\bMacintosh\b/, "macOS"],
+  [/\bLinux\b/, "Linux"]
+];
+function describeUserAgent(userAgent) {
+  if (!userAgent) {
+    return {};
+  }
+  const browser = BROWSERS.find(([pattern]) => pattern.test(userAgent))?.[1];
+  const os = SYSTEMS.find(([pattern]) => pattern.test(userAgent))?.[1];
+  return {
+    ...browser === undefined ? {} : { browser },
+    ...os === undefined ? {} : { os }
+  };
+}
+
+// src/activity/connection.ts
+async function readActivityConnections(runtime, service, query, now) {
+  const { userId, limit, before } = service.connectionsQuery(query);
+  const sessions = runtime.storage.auth?.sessions;
+  if (!sessions) {
+    return { connections: [] };
+  }
+  const page = await sessions.listByUserId({
+    projectId: runtime.projectId,
+    userId,
+    limit,
+    ...before === undefined ? {} : { before }
+  });
+  const visits = await service.sessionVisits({
+    userId,
+    sessionIds: page.sessions.map((session) => session.id)
+  });
+  const bySession = new Map(visits.map((entry) => [entry.sessionId, entry]));
+  const connections = page.sessions.map((session) => ({
+    ...sessionConnection(session, now),
+    visits: bySession.get(session.id)?.visits ?? 0,
+    latestVisits: bySession.get(session.id)?.latest ?? []
+  }));
+  const last = page.sessions.at(-1);
+  return {
+    connections,
+    ...page.hasMore && last ? { nextCursor: nextConnectionsCursor(page.sessions, last, before) } : {}
+  };
+}
+function nextConnectionsCursor(sessions, last, before) {
+  const { createdAt } = last;
+  const tied = sessions.filter((session) => session.createdAt.getTime() === createdAt.getTime());
+  const earlier = before && before.createdAt.getTime() === createdAt.getTime() ? before.skip : 0;
+  return encodeActivityConnectionsCursor({ createdAt, skip: earlier + tied.length });
+}
+function encodeActivityConnectionsCursor(cursor) {
+  return Buffer.from(JSON.stringify([cursor.createdAt.toISOString(), cursor.skip])).toString("base64url");
+}
+function decodeActivityConnectionsCursor(value) {
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (Array.isArray(parsed) && parsed.length === 2) {
+      const [at, skip] = parsed;
+      const createdAt = new Date(typeof at === "string" ? at : Number.NaN);
+      if (Number.isFinite(createdAt.getTime()) && Number.isSafeInteger(skip) && skip >= 0) {
+        return { createdAt, skip };
+      }
+    }
+  } catch {}
+  throw new Error("[Sixb] Invalid activity connections cursor.");
+}
+async function readActivityConnection(runtime, page, grant, now) {
+  const { storage, projectId } = runtime;
+  const { actor } = page.visit;
+  if (actor.type === "user") {
+    const session = await storage.auth?.sessions.getById({ projectId, id: page.sessionId });
+    return session ? sessionConnection(session, now) : undefined;
+  }
+  const session = await storage.shareSessions?.getById({ projectId, id: page.sessionId });
+  if (!session) {
+    return;
+  }
+  const revokedAt = [session.revokedAt, grant?.revokedAt].flatMap((at) => at === undefined ? [] : [at.getTime()]).sort((left, right) => left - right)[0];
+  const statuses = [
+    connectionStatus(session, now),
+    ...grant ? [connectionStatus(grant, now)] : []
+  ];
+  const status = statuses.includes("revoked") ? "revoked" : statuses.includes("expired") ? "expired" : "active";
+  return {
+    type: "share",
+    grantId: actor.grantId,
+    ...grant ? { definitionId: grant.definitionId } : {},
+    status,
+    createdAt: new Date(session.createdAt),
+    ...revokedAt === undefined ? {} : { revokedAt: new Date(revokedAt) }
+  };
+}
+function connectionStatus(session, now) {
+  if (session.revokedAt) {
+    return "revoked";
+  }
+  const expired = session.expiresAt <= now || session.absoluteExpiresAt !== undefined && session.absoluteExpiresAt <= now;
+  return expired ? "expired" : "active";
+}
+function sessionConnection(session, now) {
+  return {
+    type: "session",
+    device: describeUserAgent(session.userAgent),
+    ...session.bearer === undefined ? {} : { clientName: session.bearer.clientName },
+    status: connectionStatus(session, now),
+    createdAt: new Date(session.createdAt),
+    ...session.lastSeenAt === undefined ? {} : { lastSeenAt: new Date(session.lastSeenAt) },
+    ...session.revokedAt === undefined ? {} : { revokedAt: new Date(session.revokedAt) }
+  };
+}
+
+// src/activity/shares.ts
+async function nameSharedVisits(runtime, visits) {
+  const grants = await readGrants(runtime, visits);
+  return visits.map((visit) => withShare(visit, grants));
+}
+async function nameSharedVisit(runtime, visit) {
+  const grants = await readGrants(runtime, [visit]);
+  const grant = visit.actor.type === "share" ? grants.get(visit.actor.grantId) : undefined;
+  return { visit: withShare(visit, grants), ...grant === undefined ? {} : { grant } };
+}
+async function readGrants(runtime, visits) {
+  const ids = visits.flatMap((visit) => visit.actor.type === "share" ? [visit.actor.grantId] : []);
+  if (ids.length === 0 || !runtime.storage.shareGrants) {
+    return new Map;
+  }
+  const grants = await runtime.storage.shareGrants.getByIds({ projectId: runtime.projectId, ids });
+  return new Map(grants.map((grant) => [grant.id, grant]));
+}
+function withShare(visit, grants) {
+  const { actor } = visit;
+  const grant = actor.type === "share" ? grants.get(actor.grantId) : undefined;
+  if (actor.type !== "share" || grant === undefined) {
+    return visit;
+  }
+  return { ...visit, actor: { ...actor, definitionId: grant.definitionId } };
+}
+
+// src/actions/run-authorization.ts
+async function viewableActionRuns(objectReader, authorization, runs) {
+  if (!authorization)
+    return runs;
+  const subjectThroughCondition = (run) => run.subject.kind === "object" && authorization.viewConditions?.has(run.subject.objectTypeId) === true && isAllowed2(authorization, { kind: "action.apply", actionId: run.actionId }) ? run.subject : undefined;
+  const subjects = runs.flatMap((run) => subjectThroughCondition(run) ?? []);
+  const shown = subjects.length === 0 ? new Set : await readableSubjects(objectReader, subjects);
+  return runs.filter((run) => {
+    if (canViewActionRun2(authorization, run))
+      return true;
+    const subject = subjectThroughCondition(run);
+    return subject !== undefined && shown.has(objectBatchKey2(subject.objectTypeId, subject.primaryId));
+  });
+}
+async function readableSubjects(objectReader, subjects) {
+  const byType = new Map;
+  for (const subject of subjects) {
+    const items = byType.get(subject.objectTypeId) ?? new Map;
+    items.set(subject.primaryId, subject);
+    byType.set(subject.objectTypeId, items);
+  }
+  const readable = new Set;
+  await Promise.all([...byType.values()].map(async (items) => {
+    try {
+      const rows = await objectReader.getByPrimaryIdBatch({ items: [...items.values()] });
+      for (const key of rows.keys()) {
+        readable.add(key);
+      }
+    } catch (error) {
+      if (!(error instanceof AuthorizationError2)) {
+        throw error;
+      }
+    }
+  }));
+  return readable;
+}
+async function canReadActionRunSubject(objectReader, run) {
+  if (run.subject.kind !== "object")
+    return true;
+  const clearance = await readerClearance(objectReader);
+  return clearance?.unreadableType(run.subject.objectTypeId) === undefined;
+}
+async function unreadableActionRunTypes(objectReader) {
+  const clearance = await readerClearance(objectReader);
+  return new Set(clearance?.unreadable().types.keys());
+}
+async function canDelegationAccessActionRun(input) {
+  const subject = input.run.subject;
+  if (!input.authority.delegation || subject.kind !== "object" || !input.authority.actionApply.some((target) => target.actionId === input.run.actionId && target.subject.objectTypeId === subject.objectTypeId && target.subject.primaryId === subject.primaryId)) {
+    return false;
+  }
+  return actionRunBelongsToShareGrant({
+    storage: input.storage,
+    projectId: input.projectId,
+    run: input.run,
+    grantId: input.authority.delegation.grantId
+  });
+}
+async function actionRunBelongsToShareGrant(input) {
+  const parent = await findPrimitiveParentRequestExecution({
+    executions: input.storage.executions,
+    projectId: input.projectId,
+    executionId: input.run.executionId,
+    primitive: { kind: "action", id: input.run.actionId, runId: input.run.id }
+  });
+  const authorization = parent?.authorizationRef;
+  return authorization?.type === "delegated" && authorization.delegation.kind === "share" && authorization.delegation.grantId === input.grantId;
+}
+
+// src/execution/lineage.ts
+function nearestOwner(executionId, parentOf, isOwner) {
+  let current = executionId;
+  while (current !== undefined && !isOwner(current))
+    current = parentOf(current);
+  return current;
+}
+
+// src/runtime/ai-cost.ts
+async function resolveExecutionCosts(input) {
+  if (input.executionIds.length === 0)
+    return [];
+  if (!input.storage)
+    return input.executionIds.map(() => {
+      return;
+    });
+  return input.storage.summarizeExecutions({
+    projectId: input.projectId,
+    executionIds: input.executionIds
+  });
+}
+function addCostSummaries(summaries) {
+  const amounts = new Map;
+  let ratedCallCount = 0;
+  let unpriceableCallCount = 0;
+  let unvaluedCallCount = 0;
+  for (const summary of summaries) {
+    for (const money of summary.amounts) {
+      amounts.set(money.currency, (amounts.get(money.currency) ?? 0n) + BigInt(money.amountNanos));
+    }
+    ratedCallCount += summary.ratedCallCount;
+    unpriceableCallCount += summary.unpriceableCallCount;
+    unvaluedCallCount += summary.unvaluedCallCount;
+  }
+  if (ratedCallCount + unpriceableCallCount + unvaluedCallCount === 0) {
+    return;
+  }
+  return {
+    amounts: [...amounts].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([currency, amount]) => ({ currency, amountNanos: amount.toString() })),
+    ratedCallCount,
+    unpriceableCallCount,
+    unvaluedCallCount
+  };
+}
+
+// src/activity/timeline.ts
+var ACTIVITY_TIMELINE_LIMIT = 200;
+var SESSION_GRACE_MS = ACTIVITY_MIN_IDLE_TIMEOUT_MS / 2;
+async function composeActivityTimeline(runtime, input, now) {
+  const { page, visit } = input;
+  const { storage, projectId } = runtime;
+  const [ledger, connection] = await Promise.all([
+    storage.executions.listBySession({
+      projectId,
+      session: { type: visit.actor.type, id: page.sessionId },
+      ...sessionWindow(visit),
+      limit: ACTIVITY_TIMELINE_LIMIT
+    }),
+    readActivityConnection(runtime, page, input.grant, now)
+  ]);
+  const executions = ledger.executions;
+  const ofKind = (kind) => executions.flatMap((execution) => execution.executor.type === "primitive" && execution.executor.kind === kind ? [execution.id] : []);
+  const agentRunIds = executions.flatMap((execution) => execution.executor.type === "agent" ? [execution.executor.runId] : []);
+  const byId = new Map(executions.map((execution) => [execution.id, execution]));
+  const withAgent = executions.filter((execution) => lineage(execution, byId).some((ancestor) => ancestor.executor.type === "agent"));
+  const [actionRuns, workflowRuns, agentRuns, costs] = await Promise.all([
+    storage.actionRuns?.getByExecutionIds({ projectId, executionIds: ofKind("action") }) ?? [],
+    storage.workflowRuns?.getByExecutionIds({ projectId, executionIds: ofKind("workflow") }) ?? [],
+    storage.agents?.runs.getByIds({ projectId, ids: agentRunIds }) ?? [],
+    resolveExecutionCosts({
+      storage: storage.aiCosts,
+      projectId,
+      executionIds: withAgent.map((execution) => execution.id)
+    })
+  ]);
+  const conversations = new Map(agentRuns.flatMap((run) => run.kind === "conversation" ? [[run.executionId, run]] : []));
+  const subjects = actionRuns.flatMap((run) => run.subject.kind === "object" ? [run.subject] : []);
+  const [threads, readable, unreadableRunTypes, viewableRuns] = await Promise.all([
+    storage.agents?.threads.getByIds({
+      projectId,
+      ids: [...conversations.values()].map((run) => run.threadId)
+    }) ?? [],
+    readableSubjects(runtime.objectReader, subjects),
+    subjects.length > 0 ? unreadableActionRunTypes(runtime.objectReader) : new Set,
+    viewableActionRuns(runtime.objectReader, runtime.authorization, actionRuns)
+  ]);
+  const actionRunByExecution = new Map(actionRuns.map((run) => [run.executionId, run]));
+  const viewableRunIds = new Set(viewableRuns.map((run) => run.id));
+  const workflowRunByExecution = new Map(workflowRuns.map((run) => [run.executionId, run]));
+  const threadById = new Map(threads.map((thread) => [thread.id, thread]));
+  const observesThreads = isRuntimeAllowed2(runtime, { kind: "agentThreads.observe" });
+  const costByAgent = rollUpCosts(byId, conversations, withAgent, costs);
+  const executionEntries = executions.flatMap((execution) => {
+    const at = new Date(execution.createdAt);
+    const executor = execution.executor;
+    const authority = execution.authorizationRef;
+    if (executor.type === "primitive" && authority.type === "trustedPrimitive") {
+      if (executor.kind === "action") {
+        const run = actionRunByExecution.get(execution.id);
+        const subject = run?.subject.kind === "object" ? run.subject : undefined;
+        const object = subject && readable.has(objectBatchKey2(subject.objectTypeId, subject.primaryId)) ? { objectTypeId: subject.objectTypeId, primaryId: subject.primaryId } : undefined;
+        const runVisible = run !== undefined && viewableRunIds.has(run.id) && (subject === undefined || !unreadableRunTypes.has(subject.objectTypeId));
+        return [
+          {
+            kind: "action",
+            at,
+            executionId: execution.id,
+            actionId: authority.primitive.id,
+            runId: executor.runId,
+            status: run?.status ?? "incomplete",
+            runVisible,
+            ...object === undefined ? {} : { object }
+          }
+        ];
+      }
+      if (executor.kind === "workflow") {
+        const run = workflowRunByExecution.get(execution.id);
+        return [
+          {
+            kind: "workflow",
+            at,
+            executionId: execution.id,
+            workflowId: authority.primitive.id,
+            runId: executor.runId,
+            status: run?.status ?? "incomplete",
+            runVisible: run !== undefined && canViewWorkflowRun2(runtime.authorization, run)
+          }
+        ];
+      }
+    }
+    const conversation = conversations.get(execution.id);
+    if (conversation) {
+      const cost = costByAgent.get(execution.id);
+      const thread = threadById.get(conversation.threadId);
+      const title = thread?.title;
+      return [
+        {
+          kind: "agent",
+          at,
+          executionId: execution.id,
+          runId: conversation.id,
+          threadId: conversation.threadId,
+          ...observesThreads && thread ? { thread: title === undefined ? {} : { title } } : {},
+          status: conversation.status,
+          messages: thread?.messageCount ?? 0,
+          ...cost === undefined ? {} : { cost }
+        }
+      ];
+    }
+    return [];
+  });
+  const recorded = [
+    ...page.pageViews.map((pageView) => ({
+      kind: "page",
+      at: new Date(pageView.receivedAt),
+      sequence: pageView.sequence,
+      route: pageView.route
+    })),
+    ...page.interactions.map((interaction) => ({
+      kind: "interaction",
+      at: new Date(interaction.receivedAt),
+      sequence: interaction.sequence,
+      name: interaction.name,
+      route: interaction.route
+    }))
+  ].sort((left, right) => left.sequence - right.sequence);
+  const cutoffs = [
+    page.hasMore ? recorded.at(-1)?.at : undefined,
+    ledger.truncated ? executions.filter((execution) => execution.source.type !== "execution").at(-1)?.createdAt : undefined
+  ].flatMap((at) => at === undefined ? [] : [at.getTime()]);
+  const cutoff = cutoffs.length > 0 ? Math.min(...cutoffs) : Number.POSITIVE_INFINITY;
+  const entries = [...recorded, ...executionEntries].filter((entry) => entry.at.getTime() <= cutoff).sort((left, right) => left.at.getTime() - right.at.getTime());
+  return {
+    visit,
+    ...connection === undefined ? {} : { connection },
+    entries,
+    truncated: page.hasMore || ledger.truncated
+  };
+}
+function sessionWindow(visit) {
+  const startedAt = visit.startedAt.getTime();
+  return {
+    from: new Date(startedAt - SESSION_GRACE_MS),
+    to: new Date(Math.min(visit.lastSeenAt.getTime() + SESSION_GRACE_MS, startedAt + ACTIVITY_MAX_VISIT_MS2 - SESSION_GRACE_MS))
+  };
+}
+function lineage(execution, byId) {
+  const chain = [];
+  let current = execution;
+  while (current) {
+    chain.push(current);
+    current = current.source.type === "execution" ? byId.get(current.source.executionId) : undefined;
+  }
+  return chain;
+}
+function rollUpCosts(byId, conversations, withAgent, costs) {
+  const grouped = new Map;
+  withAgent.forEach((execution, index) => {
+    const cost = costs[index];
+    const owner = nearestOwner(execution.id, (id) => {
+      const source = byId.get(id)?.source;
+      return source?.type === "execution" ? source.executionId : undefined;
+    }, (id) => conversations.has(id));
+    if (!cost || !owner) {
+      return;
+    }
+    const summaries = grouped.get(owner) ?? [];
+    summaries.push(cost);
+    grouped.set(owner, summaries);
+  });
+  return new Map([...grouped].flatMap(([owner, summaries]) => {
+    const total = addCostSummaries(summaries);
+    return total ? [[owner, total]] : [];
+  }));
+}
+
+// src/activity/execution.ts
+var PROFILE_READ_CONCURRENCY = 8;
+function createActivityRuntime(runtime, service) {
+  const assertObservable = () => assertAuthorized2(runtime, { kind: "activity.observe" });
+  return {
+    async list(query) {
+      assertObservable();
+      const page = await service.list(query);
+      return { ...page, visits: await nameSharedVisits(runtime, page.visits) };
+    },
+    async users(query) {
+      assertObservable();
+      const page = await service.users(query);
+      const users = await mapInChunks(page.users, PROFILE_READ_CONCURRENCY, async (user) => {
+        const profile = await runtime.storage.auth?.users.getById({
+          projectId: runtime.projectId,
+          id: user.userId
+        });
+        return profile?.displayName ? { ...user, displayName: profile.displayName } : user;
+      });
+      return { users, hasMore: page.hasMore };
+    },
+    async summarize(query) {
+      assertObservable();
+      return service.summarize(query);
+    },
+    async calendar(query) {
+      assertObservable();
+      return service.calendar(query);
+    },
+    async timeline(visitId) {
+      assertObservable();
+      const page = await service.readWithSession({ id: visitId, limit: ACTIVITY_TIMELINE_LIMIT });
+      if (!page) {
+        return null;
+      }
+      const shared = await nameSharedVisit(runtime, page.visit);
+      return composeActivityTimeline(runtime, { ...shared, page }, new Date);
+    },
+    async connections(query) {
+      assertObservable();
+      return readActivityConnections(runtime, service, query, new Date);
+    }
+  };
+}
+function createActivityCaptureRuntime(runtime, service) {
+  return {
+    captureOptions() {
+      captureSource(runtime);
+      return service.captureOptions;
+    },
+    async capture(events) {
+      return service.capture(captureSource(runtime), events);
+    }
+  };
+}
+var activityCaptureKey = Symbol("sixb.activityCapture");
+function registerActivityCaptureRuntime(owner, capture) {
+  Object.defineProperty(owner, activityCaptureKey, {
+    configurable: false,
+    enumerable: false,
+    value: capture,
+    writable: false
+  });
+}
+function getActivityCaptureRuntime2(owner) {
+  const capture = owner[activityCaptureKey];
+  if (!capture) {
+    throw new Error("[Sixb] Activity capture is not registered for this execution.");
+  }
+  return capture;
+}
+function captureSource(runtime) {
+  const ref = getAuthorizationRef(runtime.runtimeAuthorization);
+  if (ref.type === "principal" && ref.principal.type === "user" && ref.credential?.type === "session") {
+    return {
+      actor: { type: "user", userId: ref.principal.id },
+      sessionId: ref.credential.id
+    };
+  }
+  if (ref.type === "delegated") {
+    return {
+      actor: { type: "share", grantId: ref.delegation.grantId },
+      sessionId: ref.delegation.sessionId
+    };
+  }
+  throw new AuthorizationError2("activity.capture", "[Sixb] Activity is recorded only for a signed-in user's session or a shared link's session.");
+}
+async function mapInChunks(items, size, map) {
+  const results = [];
+  for (let start = 0;start < items.length; start += size) {
+    const chunk = await Promise.all(items.slice(start, start + size).map(map));
+    results.push(...chunk);
+  }
+  return results;
+}
+
+// src/models/execution/session.ts
+class ModelExecutionSession {
+  runtime;
+  execution;
+  binding;
+  recorder;
+  constructor(runtime, execution) {
+    this.runtime = runtime;
+    this.execution = execution;
+  }
+  bind(input) {
+    if (this.binding)
+      throw new Error("[SixbModels] Execution attempt is already bound.");
+    this.binding = { ...input };
+  }
+  signal(signal) {
+    const binding = this.requireBinding();
+    return signal ? AbortSignal.any([binding.signal, signal]) : binding.signal;
+  }
+  async admitEmbeddingCall(admit) {
+    const admission = this.requireBinding().embeddingAdmission;
+    if (admission)
+      await admission(admit);
+    else
+      await admit();
+  }
+  accounting() {
+    const { accounting } = this.requireBinding();
+    this.recorder ??= accounting ? Promise.resolve(accounting) : this.createRecorder();
+    return this.recorder;
+  }
+  requireBinding() {
+    if (!this.binding) {
+      throw new Error("[SixbModels] Model calls require a bound request or worker execution attempt.");
+    }
+    return this.binding;
+  }
+  async createRecorder() {
+    const runtime = this.runtime;
+    const execution = this.execution;
+    const { attempt } = this.requireBinding();
+    const storage = {
+      ...requireAccountingCapabilities(runtime.storage),
+      transaction: runtime.storage.transaction.bind(runtime.storage)
+    };
+    const { requesterGroupIds } = await ensureExecutionRecord2(runtime.storage.executions, executionRecordInputFromRuntime({
+      execution,
+      runtimeAuthorization: runtime.runtimeAuthorization
+    }));
+    return new AiModelCallRecorder2({
+      storage,
+      projectId: runtime.projectId,
+      executionId: execution.id,
+      attempt,
+      requesterGroupIds,
+      limits: createAiModelCallLimitController2({
+        storage,
+        projectId: runtime.projectId,
+        requestedBy: execution.requestedBy,
+        requesterGroupIds
+      }),
+      recoverAiModelCall: (input) => enqueueAiModelCallRecovery2(runtime.queues.agents, input)
+    });
+  }
+}
+
+export { registerOntologyMutationRuntime2, getOntologyMutationRuntime2, shareOntologyMutationRuntime2, createOntologyMutationRuntime2, viewableActionRuns, readableSubjects, canReadActionRunSubject, unreadableActionRunTypes, canDelegationAccessActionRun, actionRunBelongsToShareGrant, decodeActivityConnectionsCursor, nearestOwner, resolveExecutionCosts, addCostSummaries, createActivityRuntime, createActivityCaptureRuntime, registerActivityCaptureRuntime, getActivityCaptureRuntime2, ModelExecutionSession };
+
+//# debugId=249C9537FC3C865364756E2164756E21