@sanoma-ai/workflows 0.8.1 → 0.9.0

package/src/config.ts

@@ -114,12 +114,6 @@ export interface SanomaConfig {
    * that sets it and declares a wakeup of its own.
    */
   wakeup?: true;
-  /**
-   * What the app says when it runs this repo as a demo (`sanoma demo`): `start`, the URL its
-   * banner's "Start with these apps" opens, such as the hosted wizard with the demo's apps
-   * chosen; without one, the banner has no such link.
-   */
-  demo?: { start?: string };
 }
 
 /** A config, checked, with everything a worker, client or app derives from it. */
@@ -149,18 +143,8 @@ export interface ResolvedConfig {
    * `connectors` order: what `drivers` indexes and the credentials are read from (`credentialsOf`).
    */
   driversByVendor: Map<string, Driver>;
-  /**
-   * The makers of the fakes the connectors attach, by vendor id in `connectors` order: each
-   * sandbox run makes its own. Resolved with `fakes: "instance"`, each gives its vendor's
-   * instance fake (`instanceFakes`).
-   */
+  /** The makers of the fakes the connectors attach, by vendor id in `connectors` order: each sandbox run makes its own. */
   fakes: Map<string, () => Fake<any, any>>;
-  /**
-   * Resolved with `fakes: "instance"` (a demo): each vendor's one fake, by vendor id, made once
-   * for this resolution. Each is its vendor's driver (`driversByVendor`), so live runs, sandbox
-   * runs and direct calls all call it, and the world's Givens seed it (`applyGivens`).
-   */
-  instanceFakes?: ReadonlyMap<string, Fake<any, any>>;
   /** The makers of the login halves the connectors attach, by vendor id in `connectors` order: the app makes one per public site that names it. */
   logins: ReadonlyMap<string, NonNullable<ConnectorSetup["login"]>>;
   /** The makers of the model halves the connectors attach, by vendor id in `connectors` order: the app makes each once for its model registry. */
@@ -257,17 +241,6 @@ export function rootOf(config: Pick<SanomaConfig, "root" | "file">): string | un
       : undefined;
 }
 
-/** What `resolveConfig` is given besides the config. */
-export interface ResolveOptions {
-  /**
-   * `"instance"`: run the whole instance on the connectors' fakes, as a demo does: each vendor's
-   * driver is one fake made for this resolution (`instanceFakes`), which every run and call
-   * shares. The collections stay on the config's database. Refused for a vendor whose connector
-   * attaches a driver and no fake, which would otherwise run live.
-   */
-  fakes?: "instance";
-}
-
 /**
  * Checks a config and derives what the runtime needs from it: the drivers and fakes from the
  * connectors' setups (`withSetup`), the collections' operations, driver and fake, and from
@@ -278,7 +251,7 @@ export interface ResolveOptions {
  * `root`. Each entry point resolves once: the worker and the client when they start, the app at
  * `startApp`, the `sanoma` bin when it loads the config.
  */
-export function resolveConfig(config: SanomaConfig, options: ResolveOptions = {}): ResolvedConfig {
+export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   if (!Array.isArray(config.connectors)) {
     throw new Error("The config needs `connectors`: the connectors its workflows call, as their packages export them");
   }
@@ -320,11 +293,7 @@ export function resolveConfig(config: SanomaConfig, options: ResolveOptions = {}
   ]);
   checkWakeupOps(types, ops);
   checkDatabaseOps(types, ops);
-  const fakes = makersOf(running, "fake");
-  const instanceFakes = options.fakes === "instance" ? instanceFakesOf(running, fakes) : undefined;
-  const driversByVendor = instanceFakes
-    ? new Map([...instanceFakes].map(([vendor, fake]) => [vendor, fake.driver]))
-    : new Map([...makersOf(running, "driver")].map(([vendor, make]) => [vendor, make()]));
+  const driversByVendor = new Map([...makersOf(running, "driver")].map(([vendor, make]) => [vendor, make()]));
   const remotes = new Map([...makersOf(config.connectors, "remote")].map(([vendor, make]) => [vendor, make()]));
   const drivers = indexDrivers(
     [
@@ -336,6 +305,7 @@ export function resolveConfig(config: SanomaConfig, options: ResolveOptions = {}
     ],
     ops,
   );
+  const fakes = makersOf(running, "fake");
   if (dataStore) fakes.set(DATA_VENDOR, () => collectionsFake(declared));
   const names = new Map<string, WorkflowDefinition<any, any>>();
   for (const wf of config.workflows ?? []) {
@@ -383,7 +353,6 @@ export function resolveConfig(config: SanomaConfig, options: ResolveOptions = {}
     drivers,
     driversByVendor,
     fakes,
-    ...(instanceFakes && { instanceFakes }),
     logins: makersOf(config.connectors, "login"),
     models: makersOf(config.connectors, "model"),
     remotes,
@@ -483,25 +452,6 @@ function makersOf<K extends keyof ConnectorSetup>(
   return makers;
 }
 
-/**
- * Each vendor's one fake, made now, for `resolveConfig`'s `fakes: "instance"`; `fakes` (the
- * makers) then give these. Refuses a connector that attaches a driver and no fake.
- */
-function instanceFakesOf(
-  connectors: readonly Connector<any, any>[],
-  fakes: Map<string, () => Fake<any, any>>,
-): Map<string, Fake<any, any>> {
-  const live = [...makersOf(connectors, "driver").keys()].filter((vendor) => !fakes.has(vendor));
-  if (live.length) {
-    throw new Error(
-      `The instance runs on fakes, but the connector of ${live.join(", ")} attaches no fake, so it would run live; attach one (\`withSetup\`) or leave it out`,
-    );
-  }
-  const made = new Map([...fakes].map(([vendor, make]) => [vendor, make()]));
-  for (const [vendor, fake] of made) fakes.set(vendor, () => fake);
-  return made;
-}
-
 /**
  * The `name` of `<root>/package.json`, kept whole (`@acme/ops`), when that file exists and names
  * one; else "sanoma", as for a config with no `root`. Never a `package.json` above the root: a

package/src/fake.ts

@@ -7,7 +7,6 @@ import {
   DriverError,
   type OpIdOf,
   type Specs,
-  withSetup,
 } from "./op.ts";
 import { fail, type Instance, UNREGISTERED, type WakeupApi, wakeupCalls } from "./wakeup-driver.ts";
 import { INSTANCE_TOKEN, instanceUrl } from "./wakeup-service.ts";
@@ -73,7 +72,7 @@ type Fault =
   | { kind: "hold"; released: Promise<void> };
 
 /**
- * Builds a fake vendor for a connector, for tests and demos. `ops` implements the operations
+ * Builds a fake vendor for a connector, for tests and sandbox runs. `ops` implements the operations
  * against `state`, typed by the connector as `defineDriver` does. The fake adds what a real
  * vendor does around them: a repeated idempotency key gets the first reply and changes
  * nothing. A test can make the next call fail, lose its reply, hit a rate limit or wait.
@@ -159,17 +158,6 @@ export function defineFake<V extends string, S extends Specs, T extends Record<s
   };
 }
 
-/**
- * `connector` set up with this fake instead of the one its package attaches, for a test or a demo
- * that seeds or reads the fake its runs call: live runs call its driver, and sandbox runs call it
- * too, since its maker gives this very one. A driver swap alone is `withSetup(connector, { driver })`,
- * which keeps the package's fake, so each sandbox run has one of its own. The operations are the
- * same.
- */
-export function withFake<C extends Connector<any, any>>(connector: C, fake: Fake<any, any>): C {
-  return withSetup(connector, { driver: () => fake.driver, fake: () => fake });
-}
-
 // The built-in `sanoma.wakeup`'s fake: an in-memory wakeup service that calls the host's `/wake`.
 
 /** An instance of the fake wakeup service, as it keeps one. */

package/src/run.ts

@@ -46,8 +46,6 @@ export interface WorkerState {
   drivers: Map<string, DriverFn>;
   /** The makers of the config's fake vendors, by vendor id: a sandbox run makes its own of each when it is seeded. */
   fakes: Map<string, () => Fake<any, any>>;
-  /** The instance's fakes, by vendor id, when it runs on them (`fakes: "instance"`): its sandbox runs seed and call these, not fakes of their own. */
-  instanceFakes?: ReadonlyMap<string, Fake<any, any>>;
   /** Where sandbox runs' scenarios are, the resource types their steps may name, and the steps the connectors ship. */
   scenarios?: URL;
   /** The worker's `source`, when it was given one. */

package/src/sandbox.ts

@@ -4,7 +4,7 @@ import { opIdsOf } from "./define.ts";
 import { SanomaError } from "./errors.ts";
 import type { Fake, ResourceFake } from "./fake.ts";
 import { entry, type LedgerRecord, write } from "./ledger.ts";
-import type { CallContext, DriverFn, Op } from "./op.ts";
+import type { DriverFn } from "./op.ts";
 import type { Run } from "./run.ts";
 import { memorySecrets } from "./secret.ts";
 import { type Given, loadScenarios, type Scenario } from "./scenario.ts";
@@ -58,7 +58,7 @@ export function seedResource(
   scenario: string,
   copy: ResourceFake,
   given: Extract<Given, { resource: string }>,
-): Seeds[number] {
+): Extract<LedgerRecord, { type: "scenario.seeded" }>["seeds"][number] {
   const { resource, type, name } = given;
   try {
     if ("gone" in given) {
@@ -77,81 +77,16 @@ export function seedResource(
   }
 }
 
-/** What a scenario's `Given` steps seeded, as its `scenario.seeded` record has it. */
-export type Seeds = Extract<LedgerRecord, { type: "scenario.seeded" }>["seeds"];
-
-/**
- * Where a scenario's `Given` steps go (`applyGivens`): a sandbox run's own fakes (`run`), or the
- * instance a demo runs (`instance`), its collections in the config's database and every vendor
- * on its one fake, which every run shares, so a fault, injected into a call some other run would
- * make, is refused there.
- */
-export interface GivenTarget {
-  kind: "run" | "instance";
-  /** What a `Given` operation is called through, by operation id. */
-  drivers: ReadonlyMap<string, DriverFn>;
-  /** The fakes, by vendor id: what a `Given` resource is put in, and a `run`'s faults injected into. */
-  fakes: ReadonlyMap<string, Fake<unknown>>;
-  /** The operations by id, for a fault's vendor. */
-  ops: ReadonlyMap<string, Op>;
-  /** The context of the call the `i`th `Given` makes. */
-  call(i: number, op: string): CallContext;
-}
-
-/**
- * Applies the scenario's `Given` steps to the target: calls each operation through its drivers,
- * puts or removes each resource in its vendor's fake, then, for a `run`, injects the faults.
- * Checks first that every operation it seeds has a driver there, that every resource's vendor has
- * a fake holding resources, and, for an `instance`, that it injects no fault. Returns what it
- * seeded, in order.
- */
-export async function applyGivens(scenario: Pick<Scenario, "name" | "given">, target: GivenTarget): Promise<Seeds> {
-  const { name, given } = scenario;
-  const fault = given.find((g) => "fault" in g);
-  if (fault && target.kind === "instance") {
-    throw new SanomaError(
-      "invalid_input",
-      `Scenario "${name}" injects a fault ("${fault.step}"), but its Givens go to the instance, whose fakes every run shares`,
-      { scenario: name, step: fault.step },
-    );
-  }
-  const missing = [...new Set(given.flatMap((g) => ("op" in g && !target.drivers.has(g.op) ? [g.op] : [])))];
-  if (missing.length) {
-    throw new SanomaError(
-      "invalid_input",
-      `Scenario "${name}" seeds ${missing.join(", ")}, but no fake its connectors attach implements ${missing.length > 1 ? "them" : "it"}`,
-      { scenario: name, missing },
-    );
-  }
-  const plain = missingResourceFake(scenario, target.fakes);
-  if (plain) throw plain;
-  const seeded: Seeds = [];
-  for (const [i, g] of given.entries()) {
-    if ("fault" in g) continue;
-    if ("op" in g) {
-      const output = await target.drivers.get(g.op)!(g.input, target.call(i, g.op));
-      seeded.push({ op: g.op, input: g.input, output });
-      continue;
-    }
-    // Checked above: the vendor's fake holds resources.
-    seeded.push(seedResource(name, target.fakes.get(g.vendor) as Fake<unknown> & ResourceFake, g));
-  }
-  for (const g of given) {
-    if ("fault" in g) target.fakes.get(target.ops.get(g.op)!.vendor)![g.fault](g.op);
-  }
-  return seeded;
-}
-
 /**
  * Seeds a sandbox run of the scenario `name`, from the worker, in one step: reads the scenario,
- * checks that it runs this workflow, picks the run's fakes, checks that every operation the
- * workflow uses has one, then applies the scenario's `Given` steps to them
- * (`applyGivens`) and puts their functions on the run. The run then calls those only. Its fakes
- * are its own (each vendor's maker, called once for the run), so sandbox runs share no state when
- * the makers make a new fake each; on an instance that runs on fakes (`instanceFakes`) they are
- * the instance's, which its sandbox runs share, as its live drivers are. The step's checkpoint
- * never stands in for a run's own: a run whose seeding is replayed from it has none, and fails,
- * since a sandbox run does not survive a worker restart; on an instance's fakes it goes on with them.
+ * checks that it runs this workflow, makes the run's own fakes (each vendor's maker, called once
+ * for the run), checks that every operation the workflow uses or the scenario seeds has one and
+ * that every resource it seeds has a fake holding resources, calls each `Given` operation
+ * through them, puts or removes each `Given` resource in them, injects the faults into them,
+ * then puts their functions on the run. The run then calls those only, so sandbox runs share no
+ * state when the makers make a new fake each. The step's checkpoint never stands in for them: a
+ * run whose seeding is replayed from it has none, and fails, since a sandbox run does not
+ * survive a worker restart.
  */
 export async function seedSandbox(run: Run, name: string): Promise<void> {
   const { state } = run;
@@ -168,19 +103,16 @@ export async function seedSandbox(run: Run, name: string): Promise<void> {
         throw new SanomaError("invalid_input", `No scenario named "${name}"${why}`, { scenario: name });
       }
       if (scenario.workflow !== run.workflow) {
-        const runs = scenario.workflow === undefined ? "is a world, which runs nothing" : `runs ${scenario.workflow}`;
-        throw new SanomaError("invalid_input", `Scenario "${name}" ${runs}, not ${run.workflow}`, {
+        throw new SanomaError("invalid_input", `Scenario "${name}" runs ${scenario.workflow}, not ${run.workflow}`, {
           scenario: name,
-          ...(scenario.workflow !== undefined && { workflow: scenario.workflow }),
+          workflow: scenario.workflow,
         });
       }
-      const instance = state.instanceFakes;
-      const fakes = instance ?? new Map([...state.fakes].map(([vendor, make]) => [vendor, make()]));
-      const drivers = instance
-        ? state.drivers
-        : indexDrivers([...Array.from(fakes.values(), (f) => f.driver), ...sandboxDrivers], state.ops);
-      // What the scenario seeds is checked by `applyGivens`.
-      const missing = opIdsOf(state.workflows.get(run.workflow)!).filter((id) => !drivers.has(id));
+      const fakes = new Map([...state.fakes].map(([vendor, make]) => [vendor, make()]));
+      const drivers = indexDrivers([...Array.from(fakes.values(), (f) => f.driver), ...sandboxDrivers], state.ops);
+      const uses = opIdsOf(state.workflows.get(run.workflow)!);
+      const seeding = scenario.given.flatMap((g) => ("op" in g ? [g.op] : []));
+      const missing = [...new Set([...uses, ...seeding])].filter((id) => !drivers.has(id));
       if (missing.length) {
         throw new SanomaError(
           "invalid_input",
@@ -188,20 +120,28 @@ export async function seedSandbox(run: Run, name: string): Promise<void> {
           { scenario: name, missing },
         );
       }
-      const seeded = await applyGivens(scenario, {
-        kind: instance ? "instance" : "run",
-        drivers,
-        fakes,
-        ops: state.ops,
-        call: (i, opId) => ({ idempotencyKey: `${run.id}:seed:${i}`, runId: run.id, opId, attempt: 1, secrets }),
-      });
+      const plain = missingResourceFake(scenario, fakes);
+      if (plain) throw plain;
+      const seeded: Extract<LedgerRecord, { type: "scenario.seeded" }>["seeds"] = [];
+      for (const [i, given] of scenario.given.entries()) {
+        if ("fault" in given) continue;
+        if ("op" in given) {
+          const call = { idempotencyKey: `${run.id}:seed:${i}`, runId: run.id, opId: given.op, attempt: 1, secrets };
+          const output = await drivers.get(given.op)!(given.input, call);
+          seeded.push({ op: given.op, input: given.input, output });
+          continue;
+        }
+        // Checked above: the vendor's fake holds resources.
+        seeded.push(seedResource(name, fakes.get(given.vendor) as Fake<unknown> & ResourceFake, given));
+      }
+      for (const given of scenario.given) {
+        if ("fault" in given) fakes.get(state.ops.get(given.op)!.vendor)![given.fault](given.op);
+      }
       copies = drivers;
       return { seeds: seeded };
     },
     { name: "sandbox:seed" },
   );
-  // Replayed on an instance that runs on fakes: they are the instance's, still there in this process.
-  if (!copies && state.instanceFakes) copies = state.drivers;
   if (!copies) {
     // Replayed from its checkpoint (after a worker restart, or in a fork), so the run has no fakes.
     // The records written before the restart hold the seqs from here on: the failure goes after them.

package/src/scenario.ts

@@ -136,19 +136,7 @@ export interface Scenario {
   file: string;
   /** Its line in the file: its keyword's, or for an outline's row, the row's. */
   line: number;
-  /**
-   * The workflow its `When` runs. Absent for a scenario with no `When`, a *world*: its `Given`
-   * steps alone, which a demo applies to the instance (`applyGivens`) and nothing runs or checks.
-   */
-  workflow?: string;
-  /** Its tags, as written (`@slow`), the feature's and its own. */
-  tags: string[];
-  /**
-   * When it is tagged `@moment(<person>,<path>)` (no space: a Gherkin tag has none): a moment,
-   * which a demo starts as a sandbox run by `person`, a declared person, and leaves waiting, for
-   * a visitor signed in as them to land on at `path`.
-   */
-  moment?: Moment;
+  workflow: string;
   /**
    * The scenario's own lines of its feature file, for display: from its keyword line to the end
    * of its last step (a step's doc string or table included, and an outline's examples), less
@@ -171,12 +159,6 @@ export interface Scenario {
   expect: Expectation[];
 }
 
-/** A moment's visitor and where they land: `@moment(<person>,<path>)`. */
-export interface Moment {
-  person: string;
-  path: string;
-}
-
 /** The result of one expectation against a run's ledger. */
 export interface Check {
   step: string;
@@ -399,22 +381,6 @@ function builtFor(scope: Scope): Built {
 /** A `Then` step of the generic steps: its expectation, checked against the run's records. */
 const expecting = (expect: CoreExpectation): Then => ({ expect, verify: (run) => detailOf(expect, run.records) });
 
-/**
- * `who`, as a run's start admits them (`admit`): a declared person or agent, or `anonymous`. The
- * people are the root's data files' (`readPeople`, read again only once a file changed): while
- * they declare no one, any id goes.
- */
-function actorNamed(scope: Scope, who: string): string {
-  const declared = readPeople(scope.root);
-  try {
-    return admit({ id: who }, declared).id;
-  } catch (err) {
-    if (errorCode(err) !== "not_admitted" || declared.problems.length) throw err;
-    const ids = [...principalIdsOf(declared.people), ...RUNTIME_AGENTS].join(", ");
-    throw new Error(`${who} is not a declared person or agent; resources/ declares ${ids}`, { cause: err });
-  }
-}
-
 /** The rules a scope has, and the parameter types their expressions use. */
 function rulesOf(scope: Scope): { rules: Rule[]; parameterTypes: ParameterTypeSpec[] } {
   const { types, collections } = scope;
@@ -438,10 +404,20 @@ function rulesOf(scope: Scope): { rules: Rule[]; parameterTypes: ParameterTypeSp
   ];
   const opOf = (id: unknown) => scope.ops.get(id as string)!;
   const workflowOf = (name: unknown) => scope.workflows.get(name as string)!;
-  /**
-   * `group`, a declared group or `agents`, while the people's files have no problems (`readPeople`,
-   * read again only once a file changed): while they declare no one, any group goes.
-   */
+  // The people as the root's data files declare them when a step names one (`readPeople`, read
+  // again only once a file changed): while they declare no one, any id and any group go.
+  /** `who`, as a run's start admits them (`admit`): a declared person or agent, or `anonymous`. */
+  const actorNamed = (who: string) => {
+    const declared = readPeople(scope.root);
+    try {
+      return admit({ id: who }, declared).id;
+    } catch (err) {
+      if (errorCode(err) !== "not_admitted" || declared.problems.length) throw err;
+      const ids = [...principalIdsOf(declared.people), ...RUNTIME_AGENTS].join(", ");
+      throw new Error(`${who} is not a declared person or agent; resources/ declares ${ids}`, { cause: err });
+    }
+  };
+  /** `group`, a declared group or `agents`, while the people's files have no problems. */
   const groupNamed = (group: string) => {
     const { people, problems } = readPeople(scope.root);
     if (problems.length) {
@@ -459,7 +435,7 @@ function rulesOf(scope: Scope): { rules: Rule[]; parameterTypes: ParameterTypeSp
     return { resource: id as string, vendor, type, name: name as string };
   };
   const rules: Rule[] = [
-    { kind: "actor", source: "{who} is acting", read: ([who]) => actorNamed(scope, who as string) },
+    { kind: "actor", source: "{who} is acting", read: ([who]) => actorNamed(who as string) },
     // A visitor of a public site, as a login would vouch for one; `anonymous` is a `{who}`.
     { kind: "actor", source: "a visitor is acting", read: () => visitorPrincipal("scenario", "visitor").id },
     {
@@ -906,7 +882,7 @@ function namesOf(report: Report): Map<string, string> {
 }
 
 /** What one scenario's steps said, as compiling it records them. */
-type Spec = Omit<Scenario, "approvals" | "file" | "line" | "text" | "tags" | "moment">;
+type Spec = Omit<Scenario, "workflow" | "approvals" | "file" | "line" | "text"> & { workflow?: string };
 
 /** The run's records, as a `Then` step reads them. */
 function viewOf(records: readonly LedgerRecord[]): RunView {
@@ -1202,28 +1178,6 @@ function stepError(built: Built, result: StepResult | undefined, step: PickleSte
   }
 }
 
-/**
- * The moment its tags make a scenario (`@moment(<person>,<path>)`), the person admitted as a run's
- * starter is, or undefined for none; throws, at `where`, for a malformed one or a second.
- */
-function momentOf(scope: Scope, tags: readonly string[], where: string): Moment | undefined {
-  const tagged = tags.filter((t) => t === "@moment" || t.startsWith("@moment("));
-  if (tagged.length === 0) return undefined;
-  if (tagged.length > 1) throw new Error(`${where}: ${tagged.join(" and ")}: a moment has one person and one page`);
-  const [, person, path] = /^@moment\(([^,()]+),(\/[^()]*)\)$/.exec(tagged[0]!) ?? [];
-  if (person === undefined || path === undefined) {
-    throw new Error(
-      `${where}: ${tagged[0]} needs a person and a path, as in @moment(alex,/sites/portal/requests), with no space: a tag has none`,
-    );
-  }
-  try {
-    return { person: actorNamed(scope, person), path };
-  } catch (err) {
-    if (isBug(err)) throw err;
-    throw new Error(`${where}: ${tagged[0]}: ${errorMessage(err)}`, { cause: err });
-  }
-}
-
 /** The `.feature` files under `dir`, relative to it, with `/` between directories, in order. */
 function featureFiles(dir: string): string[] {
   return readdirSync(dir, { recursive: true, encoding: "utf8" })
@@ -1253,9 +1207,8 @@ const parseErrorOf = ({ uri, line, message }: Report["parseErrors"][number]) =>
 
 /**
  * Compiles the feature files `files` (relative to `dir`) into scenarios: Cucumber runs each,
- * and its steps record what they say. A file none of whose scenarios has a `When` is of worlds.
- * A file with an error has none of its scenarios: the
- * first error in it (a step that fails or matches no step or two, a scenario with no `When` beside one with,
+ * and its steps record what they say. A file with an error has none of its scenarios: the
+ * first error in it (a step that fails or matches no step or two, a scenario with no `When`,
  * a name used twice, a file Gherkin cannot parse, no scenarios at all) is its error.
  */
 async function compile(scope: Scope, dir: string, files: string[]): Promise<LoadedScenarios> {
@@ -1291,8 +1244,6 @@ async function compile(scope: Scope, dir: string, files: string[]): Promise<Load
       try {
         const list = pickles.get(file) ?? [];
         if (list.length === 0) throw new Error(`${file}: no scenarios; add one with "Scenario: <name>"`);
-        // A feature none of whose scenarios has a When is of worlds; elsewhere a missing When is a mistake.
-        const ofWorlds = list.every((p) => specs.get(p.id)!.workflow === undefined);
         for (const pickle of list) {
           const line = lineOf(report, pickle);
           const scenario = query.findLineageBy(pickle)!.scenario!;
@@ -1301,37 +1252,16 @@ async function compile(scope: Scope, dir: string, files: string[]): Promise<Load
             const error = stepError(built, results.get(step.id), step, whereOf(report, file, step));
             if (error) throw new Error(error);
           }
-          const spec = specs.get(pickle.id)!;
-          const { workflow } = spec;
+          const { workflow, ...spec } = specs.get(pickle.id)!;
           const name = names.get(pickle.id)!;
           if (inFile.some((s) => s.name === name)) {
             throw new Error(`${where}: a second scenario named "${name}"; give each its own name`);
           }
-          const tags = pickle.tags.map((t) => t.name);
-          const moment = momentOf(scope, tags, where);
-          const common = { name, file, line, tags, text: textOf(scenario, report.texts.get(file) ?? "") };
-          if (workflow === undefined && !ofWorlds) {
+          if (workflow === undefined) {
             throw new Error(
-              `${where}: scenario "${name}" has no When: say which workflow runs, such as "When <workflow> runs with" (a feature with no When in any scenario is of worlds)`,
+              `${where}: scenario "${name}" has no When: say which workflow runs, such as "When <workflow> runs with"`,
             );
           }
-          if (workflow === undefined) {
-            // A world: its Givens alone, which nothing runs or checks.
-            const runs = moment
-              ? "is a moment, which starts a run"
-              : spec.expect[0]
-                ? `checks a run ("${spec.expect[0].step}")`
-                : spec.decisions[0]
-                  ? `decides an approval ("${spec.decisions[0].step}")`
-                  : undefined;
-            if (runs) {
-              throw new Error(
-                `${where}: scenario "${name}" has no When, so it is a world, Givens only, but it ${runs}: say which workflow runs, such as "When <workflow> runs with"`,
-              );
-            }
-            inFile.push({ ...spec, ...common, approvals: [] });
-            continue;
-          }
           // A step about a declared resource reads the report of the built-in it is about.
           for (const e of spec.expect) {
             const reads: string = "declared" in e ? ("status" in e ? DRIFT_WORKFLOW : APPLY_WORKFLOW) : workflow;
@@ -1343,9 +1273,11 @@ async function compile(scope: Scope, dir: string, files: string[]): Promise<Load
           }
           inFile.push({
             ...spec,
-            ...common,
+            name,
+            file,
+            line,
             workflow,
-            ...(moment && { moment }),
+            text: textOf(scenario, report.texts.get(file) ?? ""),
             approvals: approvalsOf(scope.workflows.get(workflow)!),
           });
         }
@@ -1436,11 +1368,10 @@ export async function loadScenarios(scope: Scope): Promise<LoadedScenarios> {
  */
 export async function check(scope: Scope, scenario: Scenario, records: readonly LedgerRecord[]): Promise<Check[]> {
   if (!scope.scenarios) throw new Error(`No scenarios directory to check scenario "${scenario.name}" from`);
-  const { file, line, name, workflow } = scenario;
-  if (workflow === undefined) throw new Error(`Scenario "${name}" is a world: it runs nothing to check`);
   const built = builtFor(scope);
+  const { file, line, name } = scenario;
   const verdicts = new Map<string, string | undefined>();
-  const report = await runFeatures(built.library, checkWorld(built, workflow, viewOf(records), verdicts), {
+  const report = await runFeatures(built.library, checkWorld(built, scenario.workflow, viewOf(records), verdicts), {
     cwd: fileURLToPath(scope.scenarios),
     files: [file],
     line,

package/src/scenarios.ts

@@ -6,13 +6,11 @@ import { type Check, check, drive, loadScenarios, type Scenario, type Scope } fr
 import { errorMessage } from "./shared.ts";
 import { startWorker } from "./worker.ts";
 
-export { type DemoState, demoState, reseed, type SeedHalf } from "./demo.ts";
-
 /*
  * `@sanoma-ai/workflows/scenarios`: runs a config's scenarios as sandbox runs, with no test
  * framework. Server-side only, like `./scenario`: it loads Cucumber and starts a worker.
  * `sanoma check` runs every scenario through `runScenarios`; `@sanoma-ai/testing/scenarios` wraps
- * `runScenario` in a vitest test per scenario. A demo seeds its instance with `reseed`.
+ * `runScenario` in a vitest test per scenario.
  */
 
 export interface RunScenarioOptions {
@@ -32,15 +30,12 @@ export interface RunScenarioOptions {
 /**
  * Runs a scenario as a sandbox run: starts its workflow with its input, as whoever it says is
  * acting, decides its approvals as it says, and checks the run's ledger against it (`check`:
- * Cucumber runs its `Then` steps). Refuses a world, which runs nothing.
+ * Cucumber runs its `Then` steps).
  */
 export async function runScenario(
   scenario: Scenario,
   { client, scope, startedBy = "scenarios", timeoutMs }: RunScenarioOptions,
 ): Promise<{ runId: string; run: RunSummary; ledger: LedgerRecord[]; checks: Check[] }> {
-  if (scenario.workflow === undefined) {
-    throw new Error(`Scenario "${scenario.name}" is a world: it seeds a demo's instance, and runs nothing`);
-  }
   const runId = await client.start(scenario.workflow, scenario.input, {
     startedBy: scenario.startedBy ?? startedBy,
     sandbox: scenario.name,
@@ -69,13 +64,6 @@ export interface RunScenariosOptions {
   log?: (line: string) => void;
 }
 
-/**
- * True for a scenario that is a test: one that runs a workflow (not a world), and not a moment
- * that decides nothing, which a demo leaves waiting at its first approval.
- */
-export const isTest = (scenario: Scenario): scenario is Scenario & { workflow: string } =>
-  scenario.workflow !== undefined && !(scenario.moment && scenario.decisions.length === 0);
-
 /**
  * Runs every scenario in `scenarios/` in the config's root, one after another, as sandbox runs
  * on a worker it starts on `databaseUrl` with an in-memory ledger (the config's `ledger` is not
@@ -84,7 +72,6 @@ export const isTest = (scenario: Scenario): scenario is Scenario & { workflow: s
  * could not be read, with why. A scenario whose run cannot be driven to its end (an approval
  * with no decision, a run still going after `timeoutMs`) fails with that error at its `When`
  * step. A config whose root has no `scenarios/`, or none in it, passes nothing and fails nothing.
- * Worlds and moments that decide nothing are no tests (`isTest`): they are left out, each logged as skipped.
  */
 export async function runScenarios(
   config: SanomaConfig,
@@ -92,9 +79,7 @@ export async function runScenarios(
 ): Promise<{ passed: string[]; failed: ScenarioFailure[] }> {
   const shared: SanomaConfig = { ...config, databaseUrl, ledger: memoryLedger() };
   const resolved = resolveConfig(shared);
-  const { scenarios: loaded, errors } = await loadScenarios(resolved);
-  const scenarios = loaded.filter(isTest);
-  for (const s of loaded) if (!isTest(s)) log?.(`skipped ${s.file} › ${s.name}: ${s.moment ? "a moment" : "a world"}`);
+  const { scenarios, errors } = await loadScenarios(resolved);
   const failed: ScenarioFailure[] = errors.map(({ file, message }) => ({
     scenario: file,
     step: "did not load",