@sixb/core 0.1.17 → 0.1.19

package/dist/chunk-y2aq6ag9.js.map

@@ -1,11 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/storage/action-runs/types.ts", "../src/storage/action-runs/failure.ts"],
-  "sourcesContent": [
-    "import type { ActionSubject } from \"../../actions\"\nimport type { SixbErrorCode, SixbFailure } from \"../../errors/types\"\nimport type { JsonValue } from \"../../json\"\n\nexport type ActionRunStatus = \"queued\" | \"running\" | \"succeeded\" | \"failed\" | \"cancelled\"\n\nexport const ACTION_RUN_PHASES = [\n  \"request\",\n  \"enqueue\",\n  \"validation\",\n  \"writeback\",\n  \"edits\",\n  \"commit\",\n  \"effects\",\n  \"cancelled\",\n] as const\n\nexport type ActionRunPhase = (typeof ACTION_RUN_PHASES)[number]\n\nexport type ActionRunParams = Readonly<Record<string, JsonValue>>\n\nexport type ActionRunPhaseStatus = \"succeeded\" | \"failed\"\n\n/** Error codes an action run or phase record can persist and expose. */\nexport const ACTION_RUN_FAILURE_CODES = [\n  \"internal.unexpected\",\n  \"runtime.cancelled\",\n  \"queue.enqueue_failed\",\n  \"action.phase_failed\",\n  \"action.read_conflict\",\n] as const satisfies readonly [SixbErrorCode, ...SixbErrorCode[]]\n\nexport type ActionRunFailureCode = (typeof ACTION_RUN_FAILURE_CODES)[number]\n\nexport interface ActionRunFailureDetails<TPhase extends ActionRunPhase = ActionRunPhase> {\n  readonly actionId: string\n  readonly runId: string\n  readonly phase: TPhase\n}\n\n/** Portable failure record with Action's required correlation details. */\nexport interface ActionRunFailure<TPhase extends ActionRunPhase = ActionRunPhase>\n  extends Omit<SixbFailure<ActionRunFailureCode>, \"details\"> {\n  readonly details: ActionRunFailureDetails<TPhase>\n}\n\nexport type ActionRunWritebackRecord =\n  | {\n      readonly status: \"succeeded\"\n      readonly completedAt: Date\n      readonly result: JsonValue\n      readonly error?: never\n    }\n  | {\n      readonly status: \"failed\"\n      readonly completedAt: Date\n      readonly result?: never\n      readonly error: ActionRunFailure<\"writeback\">\n    }\n\nexport type ActionRunEffectsRecord =\n  | {\n      readonly status: \"succeeded\"\n      readonly completedAt: Date\n      readonly error?: never\n    }\n  | {\n      readonly status: \"failed\"\n      readonly completedAt: Date\n      readonly error: ActionRunFailure<\"effects\">\n    }\n\nexport interface ActionRunRecord {\n  readonly id: string\n  readonly projectId: string\n  readonly executionId: string\n  readonly actionId: string\n  readonly subject: ActionSubject\n  readonly status: ActionRunStatus\n  readonly phase?: ActionRunPhase\n  readonly queuedAt: Date\n  readonly startedAt?: Date\n  readonly finishedAt?: Date\n  readonly params: ActionRunParams\n  readonly idempotencyKey: string\n  readonly writeback?: ActionRunWritebackRecord\n  readonly effects?: ActionRunEffectsRecord\n  readonly error?: ActionRunFailure\n}\n\nexport interface QueueActionRunInput {\n  readonly id: string\n  readonly projectId: string\n  readonly executionId: string\n  readonly actionId: string\n  readonly subject: ActionSubject\n  readonly params: ActionRunParams\n  readonly idempotencyKey: string\n  readonly queuedAt?: Date\n}\n\nexport interface StartActionRunInput {\n  readonly id: string\n  readonly projectId: string\n  readonly startedAt?: Date\n  readonly phase?: Extract<ActionRunPhase, \"validation\">\n}\n\nexport interface EnterActionRunPhaseInput {\n  readonly id: string\n  readonly projectId: string\n  readonly phase: Extract<\n    ActionRunPhase,\n    \"validation\" | \"writeback\" | \"edits\" | \"commit\" | \"effects\"\n  >\n}\n\nexport type RecordActionWritebackInput =\n  | {\n      readonly id: string\n      readonly projectId: string\n      readonly status: \"succeeded\"\n      readonly completedAt?: Date\n      readonly result: JsonValue\n    }\n  | {\n      readonly id: string\n      readonly projectId: string\n      readonly status: \"failed\"\n      readonly completedAt?: Date\n      readonly error: ActionRunFailure<\"writeback\">\n    }\n\nexport type RecordActionEffectsInput =\n  | {\n      readonly id: string\n      readonly projectId: string\n      readonly status: \"succeeded\"\n      readonly completedAt?: Date\n    }\n  | {\n      readonly id: string\n      readonly projectId: string\n      readonly status: \"failed\"\n      readonly completedAt?: Date\n      readonly error: ActionRunFailure<\"effects\">\n    }\n\nexport type FinishActionRunInput =\n  | {\n      readonly id: string\n      readonly projectId: string\n      readonly status: \"succeeded\"\n      readonly finishedAt?: Date\n      readonly phase?: ActionRunPhase\n    }\n  | {\n      readonly id: string\n      readonly projectId: string\n      readonly status: \"failed\" | \"cancelled\"\n      readonly finishedAt?: Date\n      readonly error: ActionRunFailure\n    }\n\nexport interface ListActionRunsInput {\n  readonly projectId: string\n  readonly actionId?: string\n  readonly actionIds?: readonly string[]\n  readonly subject?: ActionSubject\n  readonly objectTypeId?: string\n  readonly objectTypeIds?: readonly string[]\n  readonly primaryId?: string\n  readonly statuses?: readonly ActionRunStatus[]\n  readonly startedAfter?: Date\n  readonly startedBefore?: Date\n  readonly limit?: number\n  readonly offset?: number\n  readonly order?: \"asc\" | \"desc\"\n}\n\nexport interface ListActionRunsResult {\n  readonly runs: readonly ActionRunRecord[]\n  readonly hasMore: boolean\n  readonly total: number\n}\n\nexport interface LockActionMaterializationRunInput {\n  readonly projectId: string\n  readonly actionId: string\n  readonly runId: string\n}\n\nexport interface ActionRunStorage {\n  /** Transactional fence for Action identity and running state before a new ontology commit. */\n  lockForMaterialization(input: LockActionMaterializationRunInput): Promise<ActionRunRecord>\n  queue(input: QueueActionRunInput): Promise<ActionRunRecord>\n  start(input: StartActionRunInput): Promise<ActionRunRecord>\n  enterPhase(input: EnterActionRunPhaseInput): Promise<ActionRunRecord>\n  recordWriteback(input: RecordActionWritebackInput): Promise<ActionRunRecord>\n  recordEffects(input: RecordActionEffectsInput): Promise<ActionRunRecord>\n  finish(input: FinishActionRunInput): Promise<ActionRunRecord>\n  getById(params: { projectId: string; id: string }): Promise<ActionRunRecord | null>\n  list(input: ListActionRunsInput): Promise<ListActionRunsResult>\n}\n",
-    "import { parseSixbFailure } from \"../../errors/internal\"\nimport { isPlainRecord } from \"../../json\"\nimport {\n  ACTION_RUN_FAILURE_CODES,\n  ACTION_RUN_PHASES,\n  type ActionRunFailure,\n  type ActionRunFailureDetails,\n  type ActionRunPhase,\n} from \"./types\"\n\n/** Serializes the canonical failure plus Action's typed lifecycle extension. */\nexport function serializeActionRunFailure<TPhase extends ActionRunPhase>(\n  failure: ActionRunFailure<TPhase>,\n  expectedPhase?: TPhase\n): string {\n  const parsed =\n    expectedPhase === undefined\n      ? parseActionRunFailure(failure)\n      : parseActionRunFailure(failure, expectedPhase)\n  return JSON.stringify(parsed)\n}\n\n/** Validates and detaches an Action failure read from a storage boundary. */\nexport function parseActionRunFailure<TPhase extends ActionRunPhase>(\n  value: unknown,\n  expectedPhase: TPhase\n): ActionRunFailure<TPhase>\nexport function parseActionRunFailure(value: unknown): ActionRunFailure\nexport function parseActionRunFailure(\n  value: unknown,\n  expectedPhase?: ActionRunPhase\n): ActionRunFailure {\n  const candidate = parseStoredActionRunFailureValue(value)\n  const failure = parseSixbFailure(candidate, ACTION_RUN_FAILURE_CODES)\n  const details = failure.details\n  if (\n    !isPlainRecord(details) ||\n    typeof details.actionId !== \"string\" ||\n    typeof details.runId !== \"string\" ||\n    typeof details.phase !== \"string\" ||\n    !(ACTION_RUN_PHASES as readonly string[]).includes(details.phase)\n  ) {\n    throw new Error(\n      \"[Sixb] Stored failure is invalid: Action details must contain actionId, runId, and a known phase.\"\n    )\n  }\n  if (expectedPhase !== undefined && details.phase !== expectedPhase) {\n    throw new Error(`[Sixb] Stored Action ${expectedPhase} failure has phase '${details.phase}'.`)\n  }\n\n  return {\n    ...failure,\n    details: details as unknown as ActionRunFailureDetails,\n  }\n}\n\nfunction parseStoredActionRunFailureValue(value: unknown): unknown {\n  if (typeof value !== \"string\") return value\n  try {\n    return JSON.parse(value) as unknown\n  } catch {\n    throw new Error(\"[Sixb] Stored failure is invalid: value is not valid JSON.\")\n  }\n}\n"
-  ],
-  "mappings": ";;;;;;;;;AAMO,IAAM,qBAAoB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AASO,IAAM,4BAA2B;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;;ACnBO,SAAS,0BAAwD,CACtE,SACA,eACQ;AAAA,EACR,MAAM,SACJ,kBAAkB,YACd,uBAAsB,OAAO,IAC7B,uBAAsB,SAAS,aAAa;AAAA,EAClD,OAAO,KAAK,UAAU,MAAM;AAAA;AASvB,SAAS,sBAAqB,CACnC,OACA,eACkB;AAAA,EAClB,MAAM,YAAY,iCAAiC,KAAK;AAAA,EACxD,MAAM,UAAU,kBAAiB,WAAW,yBAAwB;AAAA,EACpE,MAAM,UAAU,QAAQ;AAAA,EACxB,IACE,CAAC,cAAc,OAAO,KACtB,OAAO,QAAQ,aAAa,YAC5B,OAAO,QAAQ,UAAU,YACzB,OAAO,QAAQ,UAAU,YACzB,CAAE,mBAAwC,SAAS,QAAQ,KAAK,GAChE;AAAA,IACA,MAAM,IAAI,MACR,mGACF;AAAA,EACF;AAAA,EACA,IAAI,kBAAkB,aAAa,QAAQ,UAAU,eAAe;AAAA,IAClE,MAAM,IAAI,MAAM,wBAAwB,oCAAoC,QAAQ,SAAS;AAAA,EAC/F;AAAA,EAEA,OAAO;AAAA,OACF;AAAA,IACH;AAAA,EACF;AAAA;AAGF,SAAS,gCAAgC,CAAC,OAAyB;AAAA,EACjE,IAAI,OAAO,UAAU;AAAA,IAAU,OAAO;AAAA,EACtC,IAAI;AAAA,IACF,OAAO,KAAK,MAAM,KAAK;AAAA,IACvB,MAAM;AAAA,IACN,MAAM,IAAI,MAAM,4DAA4D;AAAA;AAAA;",
-  "debugId": "4C1D77261542AF7164756E2164756E21",
-  "names": []
-}

package/dist/chunk-z5rnrmz1.js.map

@@ -1,11 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/scheduler/errors.ts", "../src/scheduler/runtime.ts"],
-  "sourcesContent": [
-    "export class SchedulerError extends Error {\n  readonly name = \"SchedulerError\"\n}\n\nexport class SchedulerValidationError extends Error {\n  readonly name = \"SchedulerValidationError\"\n}\n",
-    "import type { DomainEventLog } from \"../events\"\nimport { nextCronOccurrence } from \"../schedules/next-occurrence\"\nimport type { CronScheduleDefinition, ScheduleDefinition } from \"../schedules/types\"\nimport { SchedulerValidationError } from \"./errors\"\n\n/** Matches the `onError` flush budget: long enough for a healthy broker, short enough to shut down. */\nconst DEFAULT_EMIT_DRAIN_TIMEOUT_MS = 5_000\n\n/**\n * Largest delay `setTimeout` accepts before it overflows its 32-bit counter.\n *\n * Node coerces anything larger to `1`, so an unclamped monthly or yearly occurrence would fire\n * immediately, find nothing due, and re-arm on the next tick -- spinning the event loop and\n * emitting a `TimeoutOverflowWarning` for every re-arm until the occurrence came into range.\n */\nconst MAX_TIMER_DELAY_MS = 2_147_483_647\n\nexport interface SchedulerRuntimeOptions {\n  schedules: readonly ScheduleDefinition[]\n  events: DomainEventLog\n  now?: () => Date\n}\n\n/** Process lifecycle surface exposed by SixbHost. */\nexport interface SchedulerController {\n  start(): Promise<void>\n  stop(): Promise<void>\n}\n\nexport class SchedulerRuntime implements SchedulerController {\n  private readonly schedules: readonly CronScheduleDefinition[]\n  private readonly events: DomainEventLog\n  private readonly now: () => Date\n  private started = false\n  private timer: ReturnType<typeof setTimeout> | null = null\n  private readonly nextOccurrences = new Map<string, Date>()\n  private readonly pendingEmits = new Set<Promise<void>>()\n\n  constructor(options: SchedulerRuntimeOptions) {\n    this.schedules = options.schedules.filter(isCronSchedule)\n    this.events = options.events\n    this.now = options.now ?? (() => new Date())\n  }\n\n  async start(): Promise<void> {\n    if (this.started) return\n\n    const seenIds = new Set<string>()\n    for (const schedule of this.schedules) {\n      if (seenIds.has(schedule.id)) {\n        throw new SchedulerValidationError(`Duplicate schedule id '${schedule.id}'.`)\n      }\n      seenIds.add(schedule.id)\n    }\n\n    const now = this.now()\n    for (const schedule of this.schedules) {\n      // Syntactically valid expressions can still have no reachable occurrence -- `0 0 30 2 *`\n      // parses but never matches. `tick()` already tolerates that per schedule; start-up must\n      // agree, or one unschedulable expression stops every other schedule in the project and\n      // crash-loops the scheduler role.\n      try {\n        const next = nextCronOccurrence(schedule.trigger.expression, now, schedule.trigger.timezone)\n        this.nextOccurrences.set(schedule.id, next)\n      } catch (error) {\n        console.error(\n          `[Sixb] Scheduler failed to compute next occurrence for '${schedule.id}':`,\n          error\n        )\n      }\n    }\n\n    this.armTimer()\n    this.started = true\n  }\n\n  async stop(): Promise<void> {\n    if (this.timer !== null) {\n      clearTimeout(this.timer)\n      this.timer = null\n    }\n    this.nextOccurrences.clear()\n    this.started = false\n    await this.drainEmits()\n  }\n\n  /**\n   * Wait for in-flight `schedule.triggered` emits so shutdown does not return mid-delivery.\n   *\n   * Bounded on purpose. `emit` never rejects, so an emit that never *settles* — a broker that accepts\n   * the call and then hangs — would make `stop()` wait forever, turning a provider stall into a\n   * process that cannot shut down. Losing the wait is recoverable; losing shutdown is not.\n   */\n  private async drainEmits(timeoutMs = DEFAULT_EMIT_DRAIN_TIMEOUT_MS): Promise<void> {\n    if (this.pendingEmits.size === 0) return\n\n    let timer: ReturnType<typeof setTimeout> | undefined\n    try {\n      const drained = await Promise.race([\n        Promise.all([...this.pendingEmits]).then(() => true),\n        new Promise<false>((resolve) => {\n          timer = setTimeout(() => resolve(false), timeoutMs)\n        }),\n      ])\n      if (!drained) {\n        console.error(\n          `[Sixb] Timed out after ${timeoutMs}ms waiting for ${this.pendingEmits.size} schedule emit(s) to settle.`\n        )\n      }\n    } finally {\n      if (timer) clearTimeout(timer)\n    }\n  }\n\n  private armTimer(): void {\n    if (this.timer !== null) {\n      clearTimeout(this.timer)\n      this.timer = null\n    }\n\n    let earliest: Date | null = null\n    for (const date of this.nextOccurrences.values()) {\n      if (earliest === null || date.getTime() < earliest.getTime()) {\n        earliest = date\n      }\n    }\n\n    if (earliest === null) return\n\n    // Waking early is harmless: `tick()` re-arms from the same occurrence map, so a clamped delay\n    // just becomes several sleeps instead of one.\n    const delayMs = Math.min(\n      Math.max(0, earliest.getTime() - this.now().getTime()),\n      MAX_TIMER_DELAY_MS\n    )\n    this.timer = setTimeout(() => this.tick(), delayMs)\n  }\n\n  private tick(): void {\n    const now = this.now()\n\n    // Collect all due schedules\n    const dueSchedules: Array<{ schedule: CronScheduleDefinition; occurrenceAt: Date }> = []\n    for (const schedule of this.schedules) {\n      const occurrence = this.nextOccurrences.get(schedule.id)\n      if (occurrence && occurrence.getTime() <= now.getTime()) {\n        dueSchedules.push({ schedule, occurrenceAt: occurrence })\n      }\n    }\n\n    // Emit events and recalculate next occurrences\n    for (const { schedule, occurrenceAt } of dueSchedules) {\n      const occurrenceAtIso = occurrenceAt.toISOString()\n      // `emit` reports instead of rejecting, so nothing is swallowed here. The previous\n      // `void this.events.append(...)` inside a `try` could not observe a rejection at all: a broker\n      // outage meant the schedule silently never fired.\n      this.track(\n        this.events.emit(\n          {\n            events: [\n              {\n                type: \"schedule.triggered\",\n                payload: {\n                  scheduleId: schedule.id,\n                  occurrenceAt: occurrenceAtIso,\n                  triggeredAt: now.toISOString(),\n                  occurrenceKey: `${schedule.id}:${occurrenceAtIso}`,\n                },\n              },\n            ],\n          },\n          { source: \"Sixb\" }\n        )\n      )\n\n      // Calculate next from the logical occurrence time (not now) to avoid drift\n      try {\n        const next = nextCronOccurrence(\n          schedule.trigger.expression,\n          occurrenceAt,\n          schedule.trigger.timezone\n        )\n        this.nextOccurrences.set(schedule.id, next)\n      } catch (error) {\n        console.error(\n          `[Sixb] Scheduler failed to compute next occurrence for '${schedule.id}':`,\n          error\n        )\n        this.nextOccurrences.delete(schedule.id)\n      }\n    }\n\n    this.armTimer()\n  }\n\n  /** Keep in-flight emits awaitable so `stop()` does not return mid-delivery. */\n  private track(emit: Promise<void>): void {\n    const tracked = emit.finally(() => this.pendingEmits.delete(tracked))\n    this.pendingEmits.add(tracked)\n  }\n}\n\nfunction isCronSchedule(schedule: ScheduleDefinition): schedule is CronScheduleDefinition {\n  return schedule.trigger.type === \"cron\"\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "70376D7DF936561764756E2164756E21",
-  "names": []
-}

package/dist/chunk-zvx7h87b.js

@@ -1,12 +0,0 @@
-// @bun
-// src/edits/errors.ts
-class EditBatchError2 extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EditBatchError";
-  }
-}
-
-export { EditBatchError2 };
-
-//# debugId=EB0A82B55DCF58C664756E2164756E21

package/dist/chunk-zvx7h87b.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/edits/errors.ts"],
-  "sourcesContent": [
-    "export class EditBatchError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = \"EditBatchError\"\n  }\n}\n"
-  ],
-  "mappings": ";;AAAO,MAAM,wBAAuB,MAAM;AAAA,EACxC,WAAW,CAAC,SAAiB;AAAA,IAC3B,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA;AAEhB;",
-  "debugId": "EB0A82B55DCF58C664756E2164756E21",
-  "names": []
-}

package/dist/events/types/actions.d.ts

@@ -1,39 +0,0 @@
-import type { ActionSubject } from "../../actions";
-import type { ActionRunFailure } from "../../storage";
-import type { EventEnvelope } from "../envelope";
-export interface ActionRequestedEvent extends EventEnvelope {
-    type: "action.requested";
-    topic: "actions";
-    partitionKey: string;
-    payload: {
-        actionId: string;
-        subject: ActionSubject;
-        params: Record<string, unknown>;
-        runId: string;
-    };
-}
-export interface ActionCompletedEvent extends EventEnvelope {
-    type: "action.completed";
-    topic: "actions";
-    partitionKey: string;
-    payload: {
-        actionId: string;
-        runId: string;
-        subject: ActionSubject;
-        finishedAt: string;
-    };
-}
-export interface ActionFailedEvent extends EventEnvelope {
-    type: "action.failed";
-    topic: "actions";
-    partitionKey: string;
-    payload: {
-        actionId: string;
-        runId: string;
-        subject: ActionSubject;
-        error: ActionRunFailure;
-        finishedAt: string;
-    };
-}
-export type ActionEvent = ActionRequestedEvent | ActionCompletedEvent | ActionFailedEvent;
-//# sourceMappingURL=actions.d.ts.map

package/dist/events/types/actions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/events/types/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,MAAM,WAAW,oBAAqB,SAAQ,aAAa;IACzD,IAAI,EAAE,kBAAkB,CAAA;IACxB,KAAK,EAAE,SAAS,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,aAAa,CAAA;QACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,KAAK,EAAE,MAAM,CAAA;KACd,CAAA;CACF;AAED,MAAM,WAAW,oBAAqB,SAAQ,aAAa;IACzD,IAAI,EAAE,kBAAkB,CAAA;IACxB,KAAK,EAAE,SAAS,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,MAAM,CAAA;QACb,OAAO,EAAE,aAAa,CAAA;QACtB,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;CACF;AAED,MAAM,WAAW,iBAAkB,SAAQ,aAAa;IACtD,IAAI,EAAE,eAAe,CAAA;IACrB,KAAK,EAAE,SAAS,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,MAAM,CAAA;QACb,OAAO,EAAE,aAAa,CAAA;QACtB,KAAK,EAAE,gBAAgB,CAAA;QACvB,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;CACF;AAED,MAAM,MAAM,WAAW,GAAG,oBAAoB,GAAG,oBAAoB,GAAG,iBAAiB,CAAA"}

package/dist/objects/service/action-service.d.ts

@@ -1,13 +0,0 @@
-/**
- * Service layer for action operations.
- *
- * Resolves objectTypeId to a typed context and delegates to the leaf function.
- */
-import type { RequestActionResult } from "../../actions/request";
-import type { ExecutionContext } from "../../execution";
-import type { SixbRuntimeContext } from "../../runtime/types";
-import type { ActionRunRecord } from "../../storage";
-import { type RequestActionAndWaitOptions, type RequestActionOptions } from "../action";
-export declare function requestAction(runtime: SixbRuntimeContext, execution: ExecutionContext, objectTypeId: string, primaryId: string, actionId: string, params?: Record<string, unknown>, options?: RequestActionOptions): Promise<RequestActionResult>;
-export declare function requestActionAndWait(runtime: SixbRuntimeContext, execution: ExecutionContext, objectTypeId: string, primaryId: string, actionId: string, params?: Record<string, unknown>, options?: RequestActionAndWaitOptions): Promise<ActionRunRecord>;
-//# sourceMappingURL=action-service.d.ts.map

package/dist/objects/service/action-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-service.d.ts","sourceRoot":"","sources":["../../../src/objects/service/action-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,oBAAoB,EAG1B,MAAM,WAAW,CAAA;AAGlB,wBAAsB,aAAa,CACjC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,gBAAgB,EAC3B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAG9B;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,gBAAgB,EAC3B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,eAAe,CAAC,CAG1B"}

package/src/actions/run-dispatch.ts

@@ -1,282 +0,0 @@
-import { randomUUID } from "node:crypto"
-import { reportRunFailure } from "../error-reporting/capability"
-import { createSixbError, toSixbFailure } from "../errors/internal"
-import type { DomainEventLog } from "../events"
-import type { Queues } from "../queues"
-import type {
-  ActionRunFailure,
-  ActionRunParams,
-  ActionRunRecord,
-  CreateExecutionInput,
-  Storage,
-} from "../storage"
-import { ACTION_RUN_FAILURE_CODES, ActionRunError } from "../storage"
-import { parseActionRunFailure } from "../storage/action-runs/failure"
-import { actionRunParamsEqual, actionSubjectsEqual } from "../storage/action-runs/idempotency"
-import type { RequestActionResult } from "./request"
-import { createActionRunId, createActionRunIdempotencyKey } from "./run-id"
-import type { ActionSubject } from "./types"
-
-interface DispatchActionRunInput {
-  readonly errorReporterHost: object
-  readonly projectId: string
-  readonly storage: Storage
-  readonly queue: Queues["actions"]
-  readonly events: DomainEventLog
-  readonly actionId: string
-  readonly subject: ActionSubject
-  readonly params: ActionRunParams
-  readonly runId?: string
-  readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>
-  /** Runs before payload comparison or retry so an existing run cannot cross authority owners. */
-  readonly assertCanReuseExisting?: (storage: Storage, run: ActionRunRecord) => void | Promise<void>
-  /** Checks that hold only for a run this call creates; a replayed run keeps its accepted params. */
-  readonly assertNewRun?: () => Promise<void>
-}
-
-interface PreparedActionRun {
-  readonly runId: string
-  readonly idempotencyKey: string
-}
-
-type PersistedActionRun =
-  | { readonly publish: false; readonly run: ActionRunRecord }
-  | {
-      readonly publish: true
-      readonly run: ActionRunRecord
-      readonly execution: CreateExecutionInput
-      readonly queuedAt: Date
-      readonly created: boolean
-    }
-
-/** Persist an Action execution and run before publishing its queue job. */
-export async function dispatchActionRun(
-  input: DispatchActionRunInput
-): Promise<RequestActionResult> {
-  const request = prepareActionRun(input)
-  const persisted = await persistActionRun(input, request)
-  if (!persisted.publish) return existingActionRunResult(persisted.run)
-  return publishActionRun(input, persisted)
-}
-
-function prepareActionRun(input: DispatchActionRunInput): PreparedActionRun {
-  const runId = createActionRunId(input.runId)
-  return {
-    runId,
-    idempotencyKey: createActionRunIdempotencyKey(input.projectId, runId),
-  }
-}
-
-async function persistActionRun(
-  input: DispatchActionRunInput,
-  request: PreparedActionRun
-): Promise<PersistedActionRun> {
-  const actionRuns = requireActionRunStorage(input.storage)
-  const existing = await actionRuns.getById({ projectId: input.projectId, id: request.runId })
-  if (existing) {
-    await input.assertCanReuseExisting?.(input.storage, existing)
-    return reuseActionRun(input, existing)
-  }
-
-  await input.assertNewRun?.()
-  const execution = await input.createExecution(`exec_${randomUUID()}`, request.runId)
-  const queuedAt = new Date()
-  try {
-    return await input.storage.transaction(
-      async (tx): Promise<PersistedActionRun> => {
-        const transactionalRuns = requireActionRunStorage(tx)
-        const raced = await transactionalRuns.getById({
-          projectId: input.projectId,
-          id: request.runId,
-        })
-        if (raced) {
-          await input.assertCanReuseExisting?.(tx, raced)
-          assertExistingRunMatchesRequest(raced, input)
-          return { publish: false, run: raced }
-        }
-
-        await tx.executions.create(execution)
-        const run = await transactionalRuns.queue({
-          projectId: input.projectId,
-          id: request.runId,
-          executionId: execution.id,
-          actionId: input.actionId,
-          subject: input.subject,
-          params: input.params,
-          idempotencyKey: request.idempotencyKey,
-          queuedAt,
-        })
-        return { publish: true, run, execution, queuedAt, created: true }
-      },
-      { isolation: "serializable" }
-    )
-  } catch (error) {
-    if (!(error instanceof ActionRunError)) throw error
-    const raced = await actionRuns.getById({ projectId: input.projectId, id: request.runId })
-    if (!raced) throw error
-    await input.assertCanReuseExisting?.(input.storage, raced)
-    assertExistingRunMatchesRequest(raced, input)
-    return { publish: false, run: raced }
-  }
-}
-
-async function reuseActionRun(
-  input: DispatchActionRunInput,
-  existing: ActionRunRecord
-): Promise<PersistedActionRun> {
-  assertExistingRunMatchesRequest(existing, input)
-  if (!isRetryableEnqueueFailure(existing)) return { publish: false, run: existing }
-
-  const execution = await input.storage.executions.getById({
-    projectId: input.projectId,
-    id: existing.executionId,
-  })
-  if (!execution) {
-    throw new ActionRunError(
-      `[Sixb] Execution '${existing.executionId}' for Action run '${existing.id}' was not found.`
-    )
-  }
-
-  const queuedAt = new Date()
-  const run = await requireActionRunStorage(input.storage).queue({
-    projectId: input.projectId,
-    id: existing.id,
-    executionId: existing.executionId,
-    actionId: existing.actionId,
-    subject: existing.subject,
-    params: existing.params,
-    idempotencyKey: existing.idempotencyKey,
-    queuedAt,
-  })
-  return { publish: true, run, execution, queuedAt, created: false }
-}
-
-async function publishActionRun(
-  input: DispatchActionRunInput,
-  persisted: Extract<PersistedActionRun, { readonly publish: true }>
-): Promise<RequestActionResult> {
-  let job: Awaited<ReturnType<Queues["actions"]["enqueue"]>>[number] | undefined
-  try {
-    const jobs = await input.queue.enqueue({
-      projectId: input.projectId,
-      jobs: [
-        {
-          id: persisted.run.id,
-          type: "action.run.requested",
-          payload: {
-            runId: persisted.run.id,
-          },
-        },
-      ],
-    })
-    job = jobs[0]
-  } catch (error) {
-    await failActionRunPublication(input, persisted.run, error)
-    throw error
-  }
-
-  await input.events.emit(
-    {
-      events: [
-        {
-          type: "action.requested",
-          payload: {
-            actionId: persisted.run.actionId,
-            subject: persisted.run.subject,
-            params: persisted.run.params,
-            runId: persisted.run.id,
-          },
-        },
-      ],
-      correlationId: persisted.execution.correlationId,
-    },
-    { source: "Sixb" }
-  )
-
-  return {
-    runId: persisted.run.id,
-    queuedAt: persisted.queuedAt.toISOString(),
-    ...(job?.id ? { jobId: job.id } : {}),
-    created: persisted.created,
-  }
-}
-
-async function failActionRunPublication(
-  input: DispatchActionRunInput,
-  run: ActionRunRecord,
-  error: unknown
-): Promise<void> {
-  const failedAt = new Date()
-  const failure = toActionRunFailure(error, run, failedAt)
-  await requireActionRunStorage(input.storage).finish({
-    projectId: input.projectId,
-    id: run.id,
-    status: "failed",
-    finishedAt: failedAt,
-    error: failure,
-  })
-  reportRunFailure(input.errorReporterHost, error, {
-    projectId: input.projectId,
-    runKind: "action",
-    run: { runId: run.id, actionId: run.actionId },
-    failure,
-  })
-}
-
-function requireActionRunStorage(storage: Storage): NonNullable<Storage["actionRuns"]> {
-  if (!storage.actionRuns) {
-    throw new ActionRunError("[Sixb] Action run storage is not configured.")
-  }
-  return storage.actionRuns
-}
-
-function assertExistingRunMatchesRequest(
-  existing: ActionRunRecord,
-  request: Pick<DispatchActionRunInput, "actionId" | "subject" | "params">
-): void {
-  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.`
-    )
-  }
-}
-
-function isRetryableEnqueueFailure(record: ActionRunRecord): boolean {
-  return (
-    record.status === "failed" && record.phase === "enqueue" && record.error?.retryable === true
-  )
-}
-
-function existingActionRunResult(existing: ActionRunRecord): RequestActionResult {
-  return {
-    runId: existing.id,
-    queuedAt: existing.queuedAt.toISOString(),
-    created: false,
-  }
-}
-
-function toActionRunFailure(
-  error: unknown,
-  run: ActionRunRecord,
-  at: Date
-): ActionRunFailure<"enqueue"> {
-  const enqueueError = createSixbError(
-    "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,
-      at,
-    }),
-    "enqueue"
-  )
-}

package/src/actions/worker.ts

@@ -1,2 +0,0 @@
-export type { RecordEditsHandler, RecordEditsOptions } from "../edits/recorder"
-export { recordEdits } from "../edits/recorder"

package/src/events/types/actions.ts

@@ -1,42 +0,0 @@
-import type { ActionSubject } from "../../actions"
-import type { ActionRunFailure } from "../../storage"
-import type { EventEnvelope } from "../envelope"
-
-export interface ActionRequestedEvent extends EventEnvelope {
-  type: "action.requested"
-  topic: "actions"
-  partitionKey: string
-  payload: {
-    actionId: string
-    subject: ActionSubject
-    params: Record<string, unknown>
-    runId: string
-  }
-}
-
-export interface ActionCompletedEvent extends EventEnvelope {
-  type: "action.completed"
-  topic: "actions"
-  partitionKey: string
-  payload: {
-    actionId: string
-    runId: string
-    subject: ActionSubject
-    finishedAt: string
-  }
-}
-
-export interface ActionFailedEvent extends EventEnvelope {
-  type: "action.failed"
-  topic: "actions"
-  partitionKey: string
-  payload: {
-    actionId: string
-    runId: string
-    subject: ActionSubject
-    error: ActionRunFailure
-    finishedAt: string
-  }
-}
-
-export type ActionEvent = ActionRequestedEvent | ActionCompletedEvent | ActionFailedEvent

package/src/objects/service/action-service.ts

@@ -1,43 +0,0 @@
-/**
- * Service layer for action operations.
- *
- * Resolves objectTypeId to a typed context and delegates to the leaf function.
- */
-
-import type { RequestActionResult } from "../../actions/request"
-import type { ExecutionContext } from "../../execution"
-import type { SixbRuntimeContext } from "../../runtime/types"
-import type { ActionRunRecord } from "../../storage"
-import {
-  type RequestActionAndWaitOptions,
-  type RequestActionOptions,
-  requestActionAndWait as requestActionAndWaitLeaf,
-  requestAction as requestActionLeaf,
-} from "../action"
-import { resolveObjectContext } from "../context"
-
-export async function requestAction(
-  runtime: SixbRuntimeContext,
-  execution: ExecutionContext,
-  objectTypeId: string,
-  primaryId: string,
-  actionId: string,
-  params?: Record<string, unknown>,
-  options?: RequestActionOptions
-): Promise<RequestActionResult> {
-  const ctx = { ...resolveObjectContext(runtime, objectTypeId), execution }
-  return requestActionLeaf(ctx, { primaryId, actionId, params, options })
-}
-
-export async function requestActionAndWait(
-  runtime: SixbRuntimeContext,
-  execution: ExecutionContext,
-  objectTypeId: string,
-  primaryId: string,
-  actionId: string,
-  params?: Record<string, unknown>,
-  options?: RequestActionAndWaitOptions
-): Promise<ActionRunRecord> {
-  const ctx = { ...resolveObjectContext(runtime, objectTypeId), execution }
-  return requestActionAndWaitLeaf(ctx, { primaryId, actionId, params, options })
-}