@humwick/server 0.130.1 → 0.130.2

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" };
-          },
-        },
-      },
-    },
-  },
-});

package/node_modules/@humwick/kernel/config.ts

@@ -1,111 +0,0 @@
-import { relayEnv } from "@humwick/sdk/env";
-import { z } from "zod";
-import type { ConfigDecl, ConfigLayer, ResolvedConfig } from "./contract";
-
-/** Layers that may carry config values, in increasing order of precedence. `defaults` is the
- * implicit base every key is settable at; env-mapped values ride in the `host` band (§2.0). */
-const OVERRIDE_LAYERS: readonly ConfigLayer[] = ["instance", "host", "tenant", "user"];
-
-/** Explicit per-layer value sources handed to the resolver. `defaults` seeds the base; the
- * remaining layers may only carry keys the manifest marks `overridableAt` that layer. */
-export type ConfigLayerInputs = Partial<Record<ConfigLayer, Readonly<Record<string, unknown>>>>;
-
-export interface ConfigResolveOptions {
-  /** Explicit per-layer overrides. */
-  readonly layers?: ConfigLayerInputs;
-  /** Environment source for `decl.env` mappings. Defaults to `process.env`. */
-  readonly env?: Readonly<Record<string, string | undefined>>;
-}
-
-/** A layer tried to set a key it is not allowed to (default-deny) or a key the schema lacks. */
-export class ConfigResolutionError extends Error {
-  constructor(
-    readonly key: string,
-    readonly layer: ConfigLayer,
-    message: string,
-  ) {
-    super(message);
-    this.name = "ConfigResolutionError";
-  }
-}
-
-/** The merged config failed Zod validation against the manifest's schema. */
-export class ConfigValidationError extends Error {
-  constructor(readonly error: z.ZodError) {
-    super(`config failed validation:\n${error.issues.map((i) => `- ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n")}`);
-    this.name = "ConfigValidationError";
-  }
-
-  get issues(): z.ZodError["issues"] {
-    return this.error.issues;
-  }
-}
-
-function schemaKeys(decl: ConfigDecl): ReadonlySet<string> {
-  return new Set(Object.keys(decl.schema.shape));
-}
-
-function overridableAt(decl: ConfigDecl, key: string, layer: ConfigLayer): boolean {
-  const layers = (decl.overridableAt as Readonly<Record<string, readonly ConfigLayer[]>> | undefined)?.[key];
-  return layers?.includes(layer) ?? false;
-}
-
-function applyLayer(
-  merged: Record<string, unknown>,
-  layer: ConfigLayer,
-  input: Readonly<Record<string, unknown>> | undefined,
-  decl: ConfigDecl,
-  keys: ReadonlySet<string>,
-): void {
-  if (!input) return;
-  for (const [key, value] of Object.entries(input)) {
-    if (!keys.has(key)) {
-      throw new ConfigResolutionError(key, layer, `config layer '${layer}' sets unknown key '${key}'`);
-    }
-    if (layer !== "defaults" && !overridableAt(decl, key, layer)) {
-      throw new ConfigResolutionError(key, layer, `config key '${key}' is not overridable at layer '${layer}'`);
-    }
-    merged[key] = value;
-  }
-}
-
-/**
- * Resolve a module's `ctx.config` from layered sources.
- *
- * Precedence, low to high: schema defaults < `defaults` layer < `instance` < env-mapped (host
- * band) < explicit `host` < `tenant` < `user`. `defaults` seeds the base with no restriction;
- * every higher layer is default-deny — a key it carries must be listed in the manifest's
- * `overridableAt[key]` for that layer, or resolution throws. Env values arrive as raw strings,
- * so env-backed keys should use coercible schemas (`z.coerce.*`). The merged object is then
- * validated against the manifest schema (filling schema defaults for absent keys) and frozen.
- */
-export function resolveConfig<D extends ConfigDecl | undefined>(
-  decl: D,
-  options: ConfigResolveOptions = {},
-): D extends ConfigDecl ? Readonly<z.output<D["schema"]>> : ResolvedConfig<D> {
-  if (!decl) return Object.freeze({}) as never;
-  const keys = schemaKeys(decl);
-  const merged: Record<string, unknown> = {};
-
-  applyLayer(merged, "defaults", options.layers?.defaults, decl, keys);
-  applyLayer(merged, "instance", options.layers?.instance, decl, keys);
-
-  // Env-mapped values ride in the host band, but an explicit host layer input wins over them.
-  const env = options.env ?? (globalThis.process?.env as Readonly<Record<string, string | undefined>> | undefined) ?? {};
-  for (const [key, envName] of Object.entries(decl.env ?? {}) as Array<[string, string]>) {
-    const value = relayEnv(env, envName);
-    if (value === undefined) continue;
-    if (!overridableAt(decl, key, "host")) {
-      throw new ConfigResolutionError(key, "host", `config key '${key}' is env-mapped to '${envName}' but not overridable at layer 'host'`);
-    }
-    merged[key] = value;
-  }
-
-  applyLayer(merged, "host", options.layers?.host, decl, keys);
-  applyLayer(merged, "tenant", options.layers?.tenant, decl, keys);
-  applyLayer(merged, "user", options.layers?.user, decl, keys);
-
-  const parsed = decl.schema.safeParse(merged);
-  if (!parsed.success) throw new ConfigValidationError(parsed.error);
-  return Object.freeze(parsed.data) as never;
-}