@humwick/server 0.130.0 → 0.130.2

package/node_modules/@humwick/kernel/async-entity-persistence.ts

@@ -1,344 +0,0 @@
-import { Buffer } from "node:buffer";
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-import type { EntityListOptions, EntityPage, EntityStore, EntityStores, ModuleDefinition, ModuleManifest, Scope } from "./contract";
-import type { KernelEntityMutation, KernelEntityStoredRow, KernelPersistence, KernelStoredValue } from "./kernel-persistence";
-import { assertValidManifest } from "./manifest-validation";
-import {
-  EntityConflictError,
-  EntityNotFoundError,
-  EntitySessionClosedError,
-  type EntityRawListOptions,
-  type EntityRawPage,
-  type EntityRawRow,
-} from "./persistence";
-import {
-  buildModuleEntityCatalog,
-  decodeField,
-  encodeField,
-  entityCatalogOf,
-  type EntityField,
-  type EntityTable,
-} from "./persistence-schema";
-
-type EntityValue = Record<string, unknown>;
-
-interface RowState {
-  readonly table: EntityTable;
-  readonly key: unknown;
-  readonly expectedVersion: number | null;
-  value?: EntityValue;
-  deleted?: boolean;
-  mutation?: "put" | "delete";
-}
-
-function keyIdentity(table: EntityTable, key: unknown): string {
-  const encoded = encodeField(table.key, key);
-  const parts = [table.name, typeof encoded, String(encoded)];
-  return parts.map((part) => `${part.length}:${part}`).join("");
-}
-
-function decodedValue(table: EntityTable, row: KernelEntityStoredRow): EntityValue {
-  const value: EntityValue = {};
-  for (const field of table.fields) {
-    const decoded = decodeField(field, row.values[field.name]);
-    if (decoded !== undefined) value[field.name] = decoded;
-  }
-  return table.decl.schema.parse(value) as EntityValue;
-}
-
-function sign(secret: Buffer, body: string): string {
-  return createHmac("sha256", secret).update(body).digest("base64url");
-}
-
-function encodeCursor(secret: Buffer, table: EntityTable, scope: Scope, key: KernelStoredValue): string {
-  const body = Buffer.from(JSON.stringify({ v: 3, module: table.moduleId, entity: table.entityName, scope, type: typeof key, key: typeof key === "bigint" ? key.toString() : key })).toString("base64url");
-  return `${body}.${sign(secret, body)}`;
-}
-
-function decodeCursor(secret: Buffer, table: EntityTable, scope: Scope, cursor: string): KernelStoredValue {
-  try {
-    const split = cursor.lastIndexOf(".");
-    if (split < 0) throw new Error();
-    const body = cursor.slice(0, split);
-    const actual = Buffer.from(cursor.slice(split + 1));
-    const expected = Buffer.from(sign(secret, body));
-    if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) throw new Error();
-    const value = JSON.parse(Buffer.from(body, "base64url").toString("utf8")) as { v: number; module: string; entity: string; scope: string; type: string; key: KernelStoredValue };
-    if (value.v !== 3 || value.module !== table.moduleId || value.entity !== table.entityName || value.scope !== scope) throw new Error();
-    if (value.type === "bigint") return BigInt(value.key as string);
-    if (value.type !== typeof value.key) throw new Error();
-    return value.key;
-  } catch {
-    throw new TypeError(`invalid cursor for entity '${table.moduleId}.${table.entityName}'`);
-  }
-}
-
-function pageSize(limit: number | undefined): number {
-  const resolved = limit ?? 50;
-  if (!Number.isInteger(resolved) || resolved < 1 || resolved > 200) {
-    throw new RangeError("entity page limit must be an integer from 1 to 200");
-  }
-  return resolved;
-}
-
-function compareKeys(table: EntityTable, left: unknown, right: unknown): number {
-  const a = encodeField(table.key, left);
-  const b = encodeField(table.key, right);
-  return a === b ? 0 : a! < b! ? -1 : 1;
-}
-
-function matchesWhere(value: EntityValue, where: ReadonlyMap<EntityField, unknown>): boolean {
-  for (const [field, expected] of where) {
-    if (encodeField(field, value[field.name]) !== encodeField(field, expected)) return false;
-  }
-  return true;
-}
-
-export interface AsyncEntitySession<E> {
-  readonly entities: EntityStores<E>;
-  readonly pendingMutations: number;
-  seal(): void;
-  discard(): void;
-  mutations(): readonly KernelEntityMutation[];
-}
-
-class AsyncEntitySessionRuntime<E> implements AsyncEntitySession<E> {
-  readonly entities: EntityStores<E>;
-  readonly #states = new Map<string, RowState>();
-  #closed = false;
-  #finished = false;
-
-  constructor(
-    readonly port: KernelPersistence,
-    readonly ready: Promise<void>,
-    readonly scope: Scope,
-    readonly cursorSecret: Buffer,
-    tables: ReadonlyMap<string, EntityTable>,
-  ) {
-    this.entities = Object.freeze(Object.fromEntries(
-      [...tables].map(([name, table]) => [name, this.#store(table)]),
-    )) as EntityStores<E>;
-  }
-
-  get pendingMutations(): number {
-    return [...this.#states.values()].filter((state) => state.mutation !== undefined).length;
-  }
-
-  #assertOpen(): void {
-    if (this.#closed) throw new EntitySessionClosedError();
-  }
-
-  async #read(table: EntityTable, key: unknown): Promise<RowState> {
-    const identity = keyIdentity(table, key);
-    const known = this.#states.get(identity);
-    if (known) return known;
-    await this.ready;
-    const row = await this.port.entityPoint({ entity: entityCatalogOf(table), scope: this.scope, key: encodeField(table.key, key) });
-    const state: RowState = { table, key, expectedVersion: row?.version ?? null, value: row ? decodedValue(table, row) : undefined };
-    this.#states.set(identity, state);
-    return state;
-  }
-
-  #remember(table: EntityTable, row: KernelEntityStoredRow): RowState {
-    const value = decodedValue(table, row);
-    const key = value[table.key.name];
-    const identity = keyIdentity(table, key);
-    const known = this.#states.get(identity);
-    if (known) return known;
-    const state: RowState = { table, key, expectedVersion: row.version, value };
-    this.#states.set(identity, state);
-    return state;
-  }
-
-  #store(table: EntityTable): EntityStore {
-    return {
-      get: async (key) => {
-        this.#assertOpen();
-        const state = await this.#read(table, key);
-        return state.deleted ? undefined : state.value;
-      },
-      list: async (options) => this.#list(table, options as EntityListOptions<EntityValue> | undefined),
-      create: async (input) => {
-        this.#assertOpen();
-        const value = table.decl.schema.parse(input) as EntityValue;
-        const key = value[table.key.name];
-        const state = await this.#read(table, key);
-        if (!state.deleted && state.value !== undefined) throw new EntityConflictError(table.moduleId, table.entityName, key);
-        state.value = value;
-        state.deleted = false;
-        state.mutation = "put";
-        return value;
-      },
-      update: async (key, patch) => {
-        this.#assertOpen();
-        const state = await this.#read(table, key);
-        if (state.deleted || !state.value) throw new EntityNotFoundError(table.moduleId, table.entityName, key);
-        const value = table.decl.schema.parse({ ...state.value, ...patch }) as EntityValue;
-        if (keyIdentity(table, value[table.key.name]) !== keyIdentity(table, key)) throw new TypeError(`entity key '${table.key.name}' cannot be changed`);
-        state.value = value;
-        state.mutation = "put";
-        return value;
-      },
-      delete: async (key) => {
-        this.#assertOpen();
-        const state = await this.#read(table, key);
-        if (state.deleted || !state.value) return false;
-        state.deleted = true;
-        state.value = undefined;
-        state.mutation = state.expectedVersion === null ? undefined : "delete";
-        return true;
-      },
-    } as EntityStore;
-  }
-
-  async #list(table: EntityTable, options: EntityListOptions<EntityValue> | undefined): Promise<EntityPage<EntityValue>> {
-    this.#assertOpen();
-    await this.ready;
-    const limit = pageSize(options?.limit);
-    const where: Record<string, KernelStoredValue> = {};
-    const parsedWhere = new Map<EntityField, unknown>();
-    for (const [name, raw] of Object.entries(options?.where ?? {})) {
-      const field = table.fieldByName.get(name);
-      if (!field) throw new TypeError(`unknown where field '${name}' on '${table.moduleId}.${table.entityName}'`);
-      const parsed = field.schema.parse(raw);
-      parsedWhere.set(field, parsed);
-      where[name] = encodeField(field, parsed);
-    }
-    const after = options?.cursor ? decodeCursor(this.cursorSecret, table, this.scope, options.cursor) : undefined;
-    const stagedCount = [...this.#states.values()].filter((state) => state.table === table && state.mutation).length;
-    const rows = await this.port.entityList({ entity: entityCatalogOf(table), scope: this.scope, where, ...(after !== undefined ? { after } : {}), limit: limit + stagedCount + 1 });
-    const candidates = new Map<string, EntityValue>();
-    for (const row of rows) {
-      const state = this.#remember(table, row);
-      if (!state.deleted && state.value && matchesWhere(state.value, parsedWhere)) candidates.set(keyIdentity(table, state.key), state.value);
-    }
-    for (const state of this.#states.values()) {
-      if (state.table !== table || state.deleted || !state.value || !matchesWhere(state.value, parsedWhere)) continue;
-      if (after !== undefined && compareKeys(table, state.key, decodeField(table.key, after)) <= 0) continue;
-      candidates.set(keyIdentity(table, state.key), state.value);
-    }
-    const sorted = [...candidates.values()].sort((a, b) => compareKeys(table, a[table.key.name], b[table.key.name]));
-    const page = sorted.slice(0, limit);
-    const last = page.at(-1);
-    return {
-      items: page,
-      ...(sorted.length > limit && last ? { cursor: encodeCursor(this.cursorSecret, table, this.scope, encodeField(table.key, last[table.key.name])) } : {}),
-    };
-  }
-
-  seal(): void {
-    if (this.#finished) throw new EntitySessionClosedError();
-    this.#closed = true;
-  }
-
-  mutations(): readonly KernelEntityMutation[] {
-    if (!this.#closed || this.#finished) throw new EntitySessionClosedError();
-    const result: KernelEntityMutation[] = [];
-    for (const state of this.#states.values()) {
-      if (!state.mutation) continue;
-      const entity = entityCatalogOf(state.table);
-      if (state.mutation === "delete") {
-        result.push({ kind: "delete", entity, scope: this.scope, key: encodeField(state.table.key, state.key), logicalKey: state.key as string | number | bigint | boolean, expectedVersion: state.expectedVersion });
-      } else {
-        const values = Object.fromEntries(state.table.fields.map((field) => [field.name, encodeField(field, state.value![field.name])]));
-        result.push({ kind: "put", entity, scope: this.scope, key: encodeField(state.table.key, state.key), logicalKey: state.key as string | number | bigint | boolean, expectedVersion: state.expectedVersion, values });
-      }
-    }
-    this.#finished = true;
-    return Object.freeze(result);
-  }
-
-  discard(): void {
-    if (this.#finished) throw new EntitySessionClosedError();
-    this.#closed = true;
-    this.#states.clear();
-    this.#finished = true;
-  }
-}
-
-export class AsyncEntityPersistence {
-  readonly #tables = new Map<string, ReadonlyMap<string, EntityTable>>();
-  readonly #ready = new Map<string, Promise<void>>();
-  readonly #cursorSecret = randomBytes(32);
-
-  constructor(readonly port: KernelPersistence) {}
-
-  register<M extends ModuleManifest>(module: ModuleDefinition<M>): Promise<void> {
-    assertValidManifest(module);
-    if (this.#tables.has(module.id)) throw new Error(`module '${module.id}' entity persistence is already installed`);
-    const { catalog, tables } = buildModuleEntityCatalog(module);
-    this.#tables.set(module.id, tables);
-    const ready = this.port.installModule(structuredClone(catalog));
-    this.#ready.set(module.id, ready);
-    return ready;
-  }
-
-  begin<M extends ModuleManifest>(module: ModuleDefinition<M>, scope: Scope): AsyncEntitySession<M["entities"]> {
-    const tables = this.#tables.get(module.id);
-    const ready = this.#ready.get(module.id);
-    if (!tables || !ready) throw new Error(`module '${module.id}' entity persistence is not installed`);
-    return new AsyncEntitySessionRuntime(this.port, ready, scope, this.#cursorSecret, tables);
-  }
-
-  ready(moduleId: string): Promise<void> {
-    const ready = this.#ready.get(moduleId);
-    if (!ready) throw new Error(`module '${moduleId}' entity persistence is not installed`);
-    return ready;
-  }
-
-  #lookupTable(moduleId: string, entityName: string): EntityTable | undefined {
-    return this.#tables.get(moduleId)?.get(entityName);
-  }
-
-  #rawRow(table: EntityTable, scope: Scope, row: KernelEntityStoredRow): EntityRawRow {
-    const fields = decodedValue(table, row);
-    return {
-      module: table.moduleId,
-      entity: table.entityName,
-      scope,
-      key: fields[table.key.name],
-      version: row.version,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      fields,
-    };
-  }
-
-  async readEntity(moduleId: string, entityName: string, scope: Scope, key: unknown): Promise<EntityRawRow | undefined> {
-    const table = this.#lookupTable(moduleId, entityName);
-    if (!table) return undefined;
-    await this.ready(moduleId);
-    const parsedKey = table.key.schema.parse(key);
-    const row = await this.port.entityPoint({ entity: entityCatalogOf(table), scope, key: encodeField(table.key, parsedKey) });
-    return row ? this.#rawRow(table, scope, row) : undefined;
-  }
-
-  async listEntity(moduleId: string, entityName: string, scope: Scope, options: EntityRawListOptions = {}): Promise<EntityRawPage> {
-    const table = this.#lookupTable(moduleId, entityName);
-    if (!table) return { items: [] };
-    await this.ready(moduleId);
-    const limit = pageSize(options.limit);
-    const where: Record<string, KernelStoredValue> = {};
-    for (const [name, raw] of Object.entries(options.where ?? {})) {
-      const field = table.fieldByName.get(name);
-      if (!field) throw new TypeError(`unknown where field '${name}' on '${moduleId}.${entityName}'`);
-      where[name] = encodeField(field, field.schema.parse(raw));
-    }
-    const after = options.cursor ? decodeCursor(this.#cursorSecret, table, scope, options.cursor) : undefined;
-    const rows = await this.port.entityList({
-      entity: entityCatalogOf(table),
-      scope,
-      where,
-      ...(after !== undefined ? { after } : {}),
-      limit: limit + 1,
-    });
-    const items = rows.slice(0, limit).map((row) => this.#rawRow(table, scope, row));
-    const last = items.at(-1);
-    return {
-      items,
-      ...(rows.length > limit && last
-        ? { cursor: encodeCursor(this.#cursorSecret, table, scope, encodeField(table.key, last.key)) }
-        : {}),
-    };
-  }
-}

package/node_modules/@humwick/kernel/async-event-log.ts

@@ -1,107 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import type * as z from "zod";
-import type { EventWriter, ModuleDefinition, ModuleManifest, Scope } from "./contract";
-import { EventSessionClosedError, EventTopicMismatchError, UndeclaredEventError } from "./event-log";
-import type { KernelEventAppend, KernelPersistence } from "./kernel-persistence";
-
-interface PendingEvent {
-  readonly name: string;
-  readonly payload: string;
-}
-
-function normalizeJsonSafe(value: unknown): unknown {
-  if (typeof value === "number") return Object.is(value, -0) ? 0 : value;
-  if (Array.isArray(value)) return value.map(normalizeJsonSafe);
-  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, normalizeJsonSafe(entry)]));
-  }
-  return value;
-}
-
-function encodePayload(value: unknown, name: string): string {
-  try {
-    const encoded = JSON.stringify(value);
-    if (encoded === undefined || !isDeepStrictEqual(JSON.parse(encoded) as unknown, normalizeJsonSafe(value))) {
-      throw new TypeError("value changes during JSON encoding");
-    }
-    return encoded;
-  } catch (error) {
-    throw new TypeError(`event '${name}' payload must be JSON-safe: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export interface AsyncEventSession<E> {
-  readonly events: EventWriter<E>;
-  readonly pendingEvents: number;
-  seal(): void;
-  discard(): void;
-  appends(createdAt: number): readonly KernelEventAppend[];
-}
-
-class AsyncEventSessionRuntime<E> implements AsyncEventSession<E> {
-  readonly events: EventWriter<E>;
-  readonly #buffer: PendingEvent[] = [];
-  #closed = false;
-  #finished = false;
-
-  constructor(readonly scope: Scope, readonly moduleId: string, readonly schemas: ReadonlyMap<string, z.ZodType>) {
-    const prefix = `${moduleId}.`;
-    this.events = {
-      emit: async (name: string, payload: unknown) => {
-        if (this.#closed) throw new EventSessionClosedError();
-        if (!name.startsWith(prefix) || name.length === prefix.length) throw new EventTopicMismatchError(moduleId, name);
-        const schema = schemas.get(name);
-        if (!schema) throw new UndeclaredEventError(moduleId, name);
-        this.#buffer.push({ name, payload: encodePayload(schema.parse(payload), name) });
-      },
-    } as unknown as EventWriter<E>;
-  }
-
-  get pendingEvents(): number { return this.#buffer.length; }
-
-  seal(): void {
-    if (this.#finished) throw new EventSessionClosedError();
-    this.#closed = true;
-  }
-
-  appends(createdAt: number): readonly KernelEventAppend[] {
-    if (!this.#closed || this.#finished) throw new EventSessionClosedError();
-    this.#finished = true;
-    return Object.freeze(this.#buffer.map((event) => Object.freeze({
-      scope: this.scope,
-      moduleId: this.moduleId,
-      name: event.name,
-      payload: event.payload,
-      createdAt,
-    })));
-  }
-
-  discard(): void {
-    if (this.#finished) throw new EventSessionClosedError();
-    this.#closed = true;
-    this.#buffer.length = 0;
-    this.#finished = true;
-  }
-}
-
-export class AsyncEventLogPersistence {
-  readonly #modules = new Map<string, ReadonlyMap<string, z.ZodType>>();
-  constructor(readonly port: KernelPersistence) {}
-
-  register<M extends ModuleManifest>(module: ModuleDefinition<M>): void {
-    if (this.#modules.has(module.id)) throw new Error(`module '${module.id}' event log is already installed`);
-    this.#modules.set(module.id, new Map(Object.entries(module.events ?? {}) as Array<[string, z.ZodType]>));
-  }
-
-  begin<M extends ModuleManifest>(module: ModuleDefinition<M>, scope: Scope): AsyncEventSession<NonNullable<M["events"]>> {
-    const schemas = this.#modules.get(module.id);
-    if (!schemas) throw new Error(`module '${module.id}' event log is not installed`);
-    return new AsyncEventSessionRuntime(scope, module.id, schemas);
-  }
-
-  replay(scope: Scope, since: number, limit: number, moduleId?: string) {
-    return this.port.replayEvents(scope, since, limit, moduleId);
-  }
-
-  highWater(scope: Scope) { return this.port.eventHighWater(scope); }
-}

package/node_modules/@humwick/kernel/automations.pilot.ts

@@ -1,147 +0,0 @@
-import { z } from "zod";
-import { type EntityStore, type ModuleCtx, type StepResult, defineModule } from "./contract";
-
-/**
- * The M1 workflow-runtime pilot: an automations-shaped module whose workflows drive several steps
- * that mutate a kernel `run` entity, emit scoped events, and hand state from one step to the next.
- * It proves the forward-path executor end-to-end — memoization (each step journaled once), state
- * continuity (step N+1 sees exactly step N's snapshot), status projection across
- * running→sleeping/waiting→done, and that a `sleepUntil`/`waitFor` suspension parks the instance
- * without firing (durable firing is M3). Boring on purpose, like the timers pilot.
- */
-
-const runSchema = z.object({
-  id: z.string(),
-  phase: z.string(),
-  total: z.number().int(),
-});
-
-/** The un-parameterized `ModuleCtx` handed to a step narrows its own `run` store here. */
-function runStore(ctx: ModuleCtx): EntityStore<{ schema: typeof runSchema }> {
-  return (ctx.entities as unknown as { readonly run: EntityStore<{ schema: typeof runSchema }> }).run;
-}
-
-/** State threaded through the multi-step `pipeline` workflow; `log` records each step's input. */
-const pipelineState = z.object({
-  id: z.string(),
-  total: z.number().int(),
-  log: z.array(z.string()),
-});
-type PipelineState = z.output<typeof pipelineState>;
-
-/** State for the suspending pilots (`napping`/`gated`). */
-const suspendState = z.object({
-  id: z.string(),
-  total: z.number().int(),
-});
-type SuspendState = z.output<typeof suspendState>;
-
-const startInput = z.object({ id: z.string() });
-
-export const automations = defineModule({
-  id: "automations",
-  title: "Automations runtime pilot",
-  description: "Multi-step workflows proving the M1 forward-path executor (in-process only).",
-  entities: {
-    run: {
-      schema: runSchema,
-      indexes: ["phase"],
-    },
-  },
-  events: {
-    "automations.started": z.object({ id: z.string() }),
-    "automations.progressed": z.object({ id: z.string(), phase: z.string(), total: z.number().int() }),
-    "automations.completed": z.object({ id: z.string(), total: z.number().int() }),
-  },
-  workflows: {
-    // Runs to completion with no suspension: ingest → enrich → publish(done). Each step mutates the
-    // run entity, emits, and appends `${step}:saw=${incoming total}` so state continuity is directly
-    // observable in the final journaled state.
-    pipeline: {
-      input: startInput,
-      state: pipelineState,
-      init: (input): PipelineState => ({ id: input.id, total: 0, log: [] }),
-      start: "ingest",
-      steps: {
-        ingest: {
-          run: async (ctx, state: PipelineState): Promise<StepResult<PipelineState>> => {
-            const total = state.total + 1;
-            await runStore(ctx).create({ id: state.id, phase: "ingested", total });
-            await ctx.events.emit("automations.started", { id: state.id });
-            await ctx.events.emit("automations.progressed", { id: state.id, phase: "ingested", total });
-            return { state: { id: state.id, total, log: [...state.log, `ingest:saw=${state.total}`] }, next: "enrich" };
-          },
-        },
-        enrich: {
-          run: async (ctx, state: PipelineState): Promise<StepResult<PipelineState>> => {
-            const total = state.total + 1;
-            await runStore(ctx).update(state.id, { phase: "enriched", total });
-            await ctx.events.emit("automations.progressed", { id: state.id, phase: "enriched", total });
-            return { state: { id: state.id, total, log: [...state.log, `enrich:saw=${state.total}`] }, next: "publish" };
-          },
-        },
-        publish: {
-          run: async (ctx, state: PipelineState): Promise<StepResult<PipelineState>> => {
-            const total = state.total + 1;
-            await runStore(ctx).update(state.id, { phase: "published", total });
-            await ctx.events.emit("automations.completed", { id: state.id, total });
-            const log = [...state.log, `publish:saw=${state.total}`];
-            return { state: { id: state.id, total, log }, next: "done", output: { total, log } };
-          },
-        },
-      },
-    },
-
-    // Suspends on a durable timer after `warm`. M1 parks it `sleeping`; `settle` never runs until
-    // M3's timer driver fires the sleep.
-    napping: {
-      input: startInput,
-      state: suspendState,
-      init: (input): SuspendState => ({ id: input.id, total: 0 }),
-      start: "warm",
-      steps: {
-        warm: {
-          run: async (ctx, state: SuspendState): Promise<StepResult<SuspendState>> => {
-            await runStore(ctx).create({ id: state.id, phase: "warming", total: 1 });
-            await ctx.events.emit("automations.started", { id: state.id });
-            return { state: { id: state.id, total: 1 }, next: "settle", sleepUntil: ctx.clock.now() + 10_000 };
-          },
-        },
-        settle: {
-          run: async (ctx, state: SuspendState): Promise<StepResult<SuspendState>> => {
-            await runStore(ctx).update(state.id, { phase: "settled" });
-            return { state, next: "done" };
-          },
-        },
-      },
-    },
-
-    // Suspends on an event wait after `arm`. M1 parks it `waiting`; `release` never runs until M3's
-    // wait driver delivers the awaited event.
-    gated: {
-      input: startInput,
-      state: suspendState,
-      init: (input): SuspendState => ({ id: input.id, total: 0 }),
-      start: "arm",
-      steps: {
-        arm: {
-          run: async (ctx, state: SuspendState): Promise<StepResult<SuspendState>> => {
-            await runStore(ctx).create({ id: state.id, phase: "armed", total: 1 });
-            await ctx.events.emit("automations.started", { id: state.id });
-            return {
-              state: { id: state.id, total: 1 },
-              next: "release",
-              waitFor: { kind: "event", topic: "automations.progressed", correlationId: state.id },
-            };
-          },
-        },
-        release: {
-          run: async (ctx, state: SuspendState): Promise<StepResult<SuspendState>> => {
-            await runStore(ctx).update(state.id, { phase: "released" });
-            return { state, next: "done" };
-          },
-        },
-      },
-    },
-  },
-});