@motujs/runtime 0.0.0-stage → 0.1.1

package/dist/mock.d.ts

@@ -0,0 +1,286 @@
+import { type Transport } from './index.js';
+/** A response computed from the call's arguments — a client-side STUB (not backend fidelity) that lets
+ *  the lagoon FILTER/derive per request, so reactive behaviour (e.g. search -> filtered results) works
+ *  for ANY input, not just pre-recorded ones. Explicitly a stub for verifying the ISLAND's wiring. */
+export type FixtureResponder = (args: unknown[]) => unknown;
+/** What every fixture names, whether it answers with data or with a failure. */
+interface FixtureCall {
+    service: string;
+    method: string;
+    /** Optional role gate: caller must hold one of these for the call to succeed. */
+    roles?: string[];
+    /**
+     * Request-keyed matching: match this call's arguments, so a fixture can return DIFFERENT data for
+     * different inputs (e.g. filtered search results per criteria). Each slot is deep-equal to the
+     * corresponding arg, with two conveniences: an `undefined` slot is a WILDCARD, and a plain object is
+     * matched STRUCTURALLY (a subset) so you pin only the fields you care about — e.g.
+     * `[undefined, { login: 'brice' }]` matches any page with that login criterion. Omit `match`
+     * entirely for the request-agnostic fallback (the previous behaviour). A request-keyed fixture wins
+     * over the fallback when it matches.
+     */
+    match?: unknown[];
+    /**
+     * Applies from the Nth call to this `service`/`method` onward (1-indexed) instead of every call.
+     *
+     * WHY THIS DID NOT EXIST. Matching was by ARGUMENTS only, so "the first read succeeds, a later one
+     * fails" had no fixture to write: a refetch after a mutation typically repeats the EXACT SAME
+     * arguments as the read that preceded it, so `match` cannot tell them apart — only their ORDER
+     * differs. That made a whole class of property untestable: does a component correctly IGNORE a
+     * failed refresh and keep what it already had, instead of clobbering good data with nothing? That is
+     * not a state a seed can jump to — it is a transition, provable only by actually running the success
+     * then the failure, in that order, on the same instance.
+     *
+     * Two fixtures for the same call — one plain, one `{ status: 500, after: 2 }` — now say exactly
+     * that: succeed, then fail from the second call on. `after`-guarded fixtures are eligible once
+     * `callIndex >= after` and, among otherwise-equal candidates, the one with the highest SATISFIED
+     * `after` wins — the more specific temporal rule beats a call-count-agnostic one once it applies.
+     */
+    after?: number;
+}
+/** A call that answers with data. */
+export interface FixtureResponse extends FixtureCall {
+    /**
+     * The response: a fixed VALUE (static replay), or a FUNCTION of the call args (`FixtureResponder`) —
+     * a stub that derives/filters a dataset per request so the island's REACTIVE behaviour is verifiable
+     * offline (type a filter -> results actually narrow). A function response is an explicit client-side
+     * stub, NOT a claim of backend fidelity; use a value (or request-keyed `match`) for recorded truth.
+     */
+    response: unknown | FixtureResponder;
+    status?: never;
+}
+/**
+ * A call that FAILS — the state an island spends most of its life one bad afternoon away from, and
+ * the one the lagoon could not previously show.
+ *
+ * WHY THIS DID NOT EXIST, and what it cost. `MockTransport` could only fail for reasons of its own:
+ * no fixture (404) and role denied (403). A backend that answers 500 for ONE method while everything
+ * else works was not expressible, so "the mission-complete call fails — what does a person see, can
+ * they retry?" had no answer in the lagoon. `FailingTransport` fails EVERY call with one status,
+ * which is the right tool for `error-resilience` ("does it survive?") and the wrong one for a
+ * scenario ("what does it show?").
+ *
+ * The recorder knew. Capturing a real 500 through `motu fixtures record --transport http`, it wrote
+ * the fixture out COMMENTED — it had the truth and nowhere to put it. That comment is gone now.
+ *
+ * What this buys is not an error test. It is that a failure becomes an ORDINARY SCENARIO: it renders
+ * in the lagoon, gets a snapshot baseline, is measured by `responsive` and `a11y`, and can be driven
+ * by a region flow. The retry affordance nobody could look at is now a picture someone accepted.
+ */
+export interface FixtureFailure extends FixtureCall {
+    /** The HTTP status the call answers with. Thrown as a `MotuError`, exactly as a real one would be. */
+    status: number;
+    /** Optional message. Defaults to something that says the failure was declared, not accidental. */
+    message?: string;
+    response?: never;
+}
+/**
+ * One recorded or hand-written answer to a contract call.
+ *
+ * A UNION, not an optional `status`, so the two forms cannot be mixed: a fixture that carries both a
+ * response and a status is a fixture whose author did not decide, and the compiler says so at the
+ * point of writing rather than the mock picking one at runtime.
+ */
+export type Fixture = FixtureResponse | FixtureFailure;
+/**
+ * A lagoon input case: seed the archipelago store, expect the island to render accordingly. Two
+ * scenarios with different seeds that produce DIFFERENT rendered output prove data actually flows
+ * across the seam (criteria -> contract -> render), not merely that the wiring type-checks. Consumed
+ * by `motu island verify`'s differentiation check (exported alongside `fixtures` from a
+ * `fixtures.mock.ts`).
+ */
+export interface Scenario {
+    /** Human label for the case (shown in verify output). */
+    name?: string;
+    /**
+     * This scenario renders NOTHING, on purpose — and why (a banner silent when nothing is wrong, a
+     * palette closed). `data-flow` then counts the empty render as this scenario's answer instead of
+     * refusing the comparison, and ASSERTS it: if the island renders something here, the check fails.
+     * A sentence, not a flag — an empty reason is no declaration.
+     */
+    blank?: string;
+    /** Store seed for this case, e.g. `{ criteria: { login: 'brice' } }`. */
+    seed?: Record<string, unknown>;
+    /**
+     * Keys provided AFTER the island has mounted and settled — a value that ARRIVES, rather than one the
+     * island starts with. Applied on top of `seed`; the render is read once these have landed.
+     *
+     * FOR A COMPONENT THAT TELLS "ALREADY THERE" FROM "JUST HAPPENED", and nothing else. Peps' sphère
+     * sheet treats a request present at mount as dismissed (so « Ma Base » does not reopen the last
+     * sphère on every visit) and opens only on one that arrives later — a rule no seed can cross, so
+     * the opened sheet had no island scenario at all. `afterMount: { request }` is that arrival.
+     *
+     * DATA, not a script: one batch of keys, provided through the same seam the page uses, never a
+     * click or a wait. The keys are pinned like the seed's, so a region source cannot replace them. If
+     * the end state can be written as a seed, write it as a seed.
+     */
+    afterMount?: Record<string, unknown>;
+    /**
+     * A scripted interaction, run after the seed settles and before the render is read.
+     *
+     * NOT the same rule as `RegionStep` — that model bans synthetic clicks because a FLOW tests region
+     * coupling GIVEN an island's declared output already fired (`emit` simulates the outcome, on
+     * purpose, so a flow never runs real component code). A scenario is the opposite kind of claim: it
+     * IS the island's own code running, so there is nothing to simulate around. What a click here proves
+     * is exactly what `emit` cannot: whether the component's OWN internal handler — a retry, a catch
+     * block, a debounce — behaves correctly when actually invoked, not merely when its outcome is
+     * assumed.
+     *
+     * USE IT FOR A TRANSITION NO SEED CAN DESCRIBE, and nothing else. A state is a seed's job; this is
+     * for "succeeded, THEN failed" on one live instance — the shape a seed cannot reach because the
+     * second half only exists after the first half ran. If you can write the end state as a seed, do.
+     *
+     * THE CONSTRAINTS ARE THE POINT, because the objection they answer is real: a harness that accepts
+     * arbitrary DOM scripting becomes a second, untyped test suite that no longer derives from the
+     * declarations. So this stays deliberately too weak to be one —
+     *
+     *   - CLICK ONLY. No typing, no waits, no conditionals, no navigation. Adding those is how a
+     *     stimulus turns into a script.
+     *   - ACCESSIBLE NAME ONLY. Never a CSS selector — the same vocabulary `expectRender` reads FROM,
+     *     so an interaction can only reach what a person could perceive and act on.
+     *   - NO ASSERTIONS HERE. A scenario's claim stays its rendered output; interactions are stimulus,
+     *     never expectation. There is deliberately nowhere in this type to put one.
+     *   - SHORT. Enough clicks to reach the transition, not to walk a user journey.
+     *
+     * And it must EARN its place: `interaction-effective` fails an interaction that moved neither the
+     * render nor any request — the sibling of `flow-mutation`'s "a step that cannot fail is not a
+     * check". Note that it deliberately does NOT require the render to change, because the properties
+     * this exists for often assert that it must not.
+     */
+    interactions?: ScenarioInteraction[];
+}
+export interface ScenarioInteraction {
+    /**
+     * Click the first visible control (button/checkbox/link/etc.) whose ACCESSIBLE NAME matches
+     * (substring, case-sensitive). Roles are tried most-specific first, so a checkbox wins over a
+     * button wrapping it. Deliberately the only verb this type has — see `Scenario.interactions`.
+     */
+    click: string;
+}
+/**
+ * A region's declared FLOW: a state, an act, and what the region should hold afterwards.
+ *
+ * Scenarios describe a state; this describes what happens next. `emit` fires an island's DECLARED
+ * output — the same seam the wiring probe uses — so a flow can only ever do what the archipelago says
+ * that island can do. NO SELECTORS: the moment a harness accepts arbitrary DOM scripting it is a
+ * second, untyped test suite, and it stops being derivable from the declarations.
+ *
+ * `click` is the one exception, and it exists because the rule above was hiding a FALSE CLAIM. A flow
+ * that only ever emits enters the region PAST the component's own handler, so a search box whose
+ * `onChange` was dropped is inert on screen while every flow still passes: the coupling is reported as
+ * carrying when nothing a user does can make it carry. Measured twice — once as a logic mutation, once
+ * as a wiring one — and in both cases the flow was green and the feature was dead.
+ *
+ * It inherits the constraint that keeps island scenarios from being browser tests: a control is named
+ * by its ACCESSIBLE NAME, never a selector, resolved by the same function `Scenario.click` uses. A
+ * control with no accessible name cannot be driven, which is a feature. There is deliberately no
+ * `fill`, no waits and no scripting — a flow that needs those has become a browser test, and Playwright
+ * is better at that than this will ever be.
+ *
+ * Lives beside the archipelago (`<id>.evidence.ts`), because the mapping it asserts is the region's.
+ */
+export interface RegionScenario {
+    /**
+     * The lagoon WORLD this flow runs in (`defineWorlds` in the override file). Absent = the default
+     * lagoon. A world re-answers what the lagoon was handed — a source's port, a seed, a member fact — for
+     * the states no flow could otherwise reach.
+     */
+    world?: string;
+    name?: string;
+    /** Region keys to establish before the flow runs. */
+    seed?: Record<string, unknown>;
+    steps?: RegionStep[];
+}
+export interface RegionStep {
+    /** The island output to fire, in the region's own vocabulary. */
+    emit?: {
+        slot: string;
+        event: string;
+        detail?: unknown;
+    };
+    /**
+     * The HOST feeding region keys — the other way a region moves.
+     *
+     * Every step used to be an `emit`, which quietly meant only regions whose islands WRITE could have
+     * flows at all. Twenty's record page is the counter-example: its two widgets both read
+     * `editingWidgetId`, the app owns it, and the coupling is real enough to watch one island change
+     * while the other does not. That flow was undeclarable until this existed.
+     */
+    provide?: Record<string, unknown>;
+    /** Region keys and the values they must hold afterwards. Compared structurally. */
+    expect?: Record<string, unknown>;
+    /**
+     * What an island RENDERS afterwards, by slot — the assertion a store read cannot make.
+     *
+     * `expect` names region keys, so a step whose `expect` names the key its `emit` targets is a
+     * tautology: it cannot fail unless the wiring is broken. Ending on another island's rendered text
+     * is the thing that fails when the store is right and the screen is wrong.
+     *
+     * THE SLOT INCLUDES WHAT IT OPENED. A dialog, popover, dropdown or select built on a portal renders
+     * as a SIBLING of the slot under `document.body`, so everything a member sees after clicking a
+     * control in that slot used to be unassertable — a flow could open an overlay, watch the right text
+     * appear, and have nothing it was allowed to name. The slot's surface therefore follows ARIA
+     * ownership (`aria-controls` / `aria-owns` / `aria-describedby`, transitively, since overlays nest),
+     * which is how a portal declares that content is its own and how a screen reader follows it. Radix —
+     * and every shadcn component on it — already wires those, so nothing in the application needs
+     * annotating. Content inside another slot is never collected: one island's overlay can never satisfy
+     * another island's assertion, which is the coupling this check exists to catch.
+     */
+    expectRender?: Record<string, string | {
+        text?: string;
+        notText?: string;
+    }>;
+    /**
+     * The backend calls this step may make — and ONLY these. `[]` says it asks for nothing.
+     *
+     * `flow-calls` already fails a call nothing ANSWERED; this fails a call nobody EXPECTED, answered or
+     * not. Without it a change that made a state ask for more stayed green as long as the extra call was
+     * answered — bench/evidence's B9 refetched the remote servers on every load, and the only trace was
+     * "1 answered" in the lagoon's calls strip. An entry is `METHOD /path` (query ignored), `/path` (any
+     * method) or the declaration's label (`shots.list`). Compared as sets: how often a call repeated is
+     * not the claim. Step 1 includes the calls the mount made.
+     *
+     * Not part of `flow-mutation`: "asks for nothing" rarely depends on the step's input, and a mutant
+     * judged on it would report every such step as a constant. It is judged on `expect`/`expectRender`.
+     */
+    expectCalls?: readonly string[];
+    /**
+     * A control to click, BY ACCESSIBLE NAME — the user's half of a coupling.
+     *
+     * `emit` proves the region carries a declared output. This proves something the region cannot say by
+     * itself: that acting on what is rendered actually produces that output. The two together are the
+     * whole claim; `emit` alone is the half that can pass while the screen is dead.
+     *
+     * Resolved exactly as an island scenario's `click` is — exact accessible name first, then the
+     * narrowest containing match, visible elements only, searching the document so a control inside a
+     * portal is reachable.
+     */
+    click?: string;
+}
+/**
+ * Backend-free transport for Storybook / sandbox. Replays fixtures and, when a fixture declares
+ * `roles`, throws a 403 MotuError if the sandbox's currently-selected role does not satisfy them —
+ * letting you demo the authorization behaviour with no server running. When a fixture declares
+ * `match`, calls are resolved by their ARGUMENTS so one service/method can return different data per
+ * request (request-keyed fixtures), falling back to a match-less fixture for the same method.
+ */
+export declare class MockTransport implements Transport {
+    private readonly fixtures;
+    private currentRoles;
+    /** How many times each `service/method` has been called — what `after` counts against. */
+    private readonly callCounts;
+    constructor(fixtures: Fixture[], currentRoles?: string[]);
+    setRoles(roles: string[]): void;
+    call<T>(service: string, method: string, args: unknown[]): Promise<T>;
+}
+/**
+ * A transport that fails every call with a fixed status. Used by `motu island verify` to mount an
+ * island against a broken backend and check it renders an error state instead of white-screening or
+ * leaking an unhandled rejection.
+ */
+export declare class FailingTransport implements Transport {
+    private readonly status;
+    constructor(status?: number);
+    call<T>(service: string, method: string): Promise<T>;
+}
+export {};
+//# sourceMappingURL=mock.d.ts.map

package/dist/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../src/mock.ts"],"names":[],"mappings":"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"}

package/dist/mock.js

@@ -0,0 +1,83 @@
+import { MotuError } from './index.js';
+/** Narrow to the failing form. */
+function isFailure(f) {
+    return typeof f.status === 'number';
+}
+/** Structural arg matching: `undefined` pattern slot = wildcard; plain objects match as a subset. */
+function matchValue(pattern, actual) {
+    if (pattern === undefined)
+        return true;
+    if (pattern === null || typeof pattern !== 'object')
+        return pattern === actual;
+    if (Array.isArray(pattern)) {
+        return Array.isArray(actual) && pattern.every((p, i) => matchValue(p, actual[i]));
+    }
+    if (actual === null || typeof actual !== 'object')
+        return false;
+    return Object.entries(pattern).every(([k, v]) => matchValue(v, actual[k]));
+}
+function argsMatch(pattern, args) {
+    return pattern.every((p, i) => matchValue(p, args[i]));
+}
+/**
+ * Backend-free transport for Storybook / sandbox. Replays fixtures and, when a fixture declares
+ * `roles`, throws a 403 MotuError if the sandbox's currently-selected role does not satisfy them —
+ * letting you demo the authorization behaviour with no server running. When a fixture declares
+ * `match`, calls are resolved by their ARGUMENTS so one service/method can return different data per
+ * request (request-keyed fixtures), falling back to a match-less fixture for the same method.
+ */
+export class MockTransport {
+    constructor(fixtures, currentRoles = []) {
+        this.fixtures = fixtures;
+        this.currentRoles = currentRoles;
+        /** How many times each `service/method` has been called — what `after` counts against. */
+        this.callCounts = new Map();
+    }
+    setRoles(roles) {
+        this.currentRoles = roles;
+    }
+    async call(service, method, args) {
+        const key = `${service}/${method}`;
+        const callIndex = (this.callCounts.get(key) ?? 0) + 1;
+        this.callCounts.set(key, callIndex);
+        const candidates = this.fixtures.filter((f) => f.service === service && f.method === method && (f.after === undefined || callIndex >= f.after));
+        if (!candidates.length) {
+            throw new MotuError(404, `mock: no fixture for ${service}/${method}`);
+        }
+        // Prefer a request-keyed fixture whose `match` fits these args; else the request-agnostic fallback.
+        // Within either tier, break ties toward the highest SATISFIED `after` — the fixture guarding "from
+        // call N on" is the more specific rule once it applies, and should win over one that fires always.
+        const mostRelevant = (fs) => [...fs].sort((a, b) => (b.after ?? -1) - (a.after ?? -1))[0];
+        const fixture = mostRelevant(candidates.filter((f) => f.match && argsMatch(f.match, args))) ??
+            mostRelevant(candidates.filter((f) => !f.match));
+        if (!fixture) {
+            throw new MotuError(404, `mock: no fixture for ${service}/${method} matching these arguments`);
+        }
+        if (fixture.roles && !fixture.roles.some((r) => this.currentRoles.includes(r))) {
+            throw new MotuError(403, `mock: role denied for ${service}/${method}`);
+        }
+        // A DECLARED failure. Thrown the way the real transport throws, so the island takes the same code
+        // path it will take in the ocean — not a special "mock is sad" path it would never otherwise run.
+        if (isFailure(fixture)) {
+            throw new MotuError(fixture.status, fixture.message ?? `mock: declared ${fixture.status} for ${service}/${method}`, true);
+        }
+        // A function response derives the result from the args (a stub filter) so reactive behaviour works
+        // for any input; a value response is a static replay.
+        const { response } = fixture;
+        return (typeof response === 'function' ? response(args) : response);
+    }
+}
+/**
+ * A transport that fails every call with a fixed status. Used by `motu island verify` to mount an
+ * island against a broken backend and check it renders an error state instead of white-screening or
+ * leaking an unhandled rejection.
+ */
+export class FailingTransport {
+    constructor(status = 500) {
+        this.status = status;
+    }
+    async call(service, method) {
+        throw new MotuError(this.status, `forced ${this.status} for ${service}/${method}`);
+    }
+}
+//# sourceMappingURL=mock.js.map

package/dist/mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.js","sourceRoot":"","sources":["../src/mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkB,MAAM,SAAS,CAAC;AAyFpD,kCAAkC;AAClC,SAAS,SAAS,CAAC,CAAU;IAC3B,OAAO,OAAQ,CAAoB,CAAC,MAAM,KAAK,QAAQ,CAAC;AAC1D,CAAC;AA8KD,qGAAqG;AACrG,SAAS,UAAU,CAAC,OAAgB,EAAE,MAAe;IACnD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACvC,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,OAAO,KAAK,MAAM,CAAC;IAC/E,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpF,CAAC;IACD,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAChE,OAAO,MAAM,CAAC,OAAO,CAAC,OAAkC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CACzE,UAAU,CAAC,CAAC,EAAG,MAAkC,CAAC,CAAC,CAAC,CAAC,CACtD,CAAC;AACJ,CAAC;AAED,SAAS,SAAS,CAAC,OAAkB,EAAE,IAAe;IACpD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,aAAa;IAIxB,YACmB,QAAmB,EAC5B,eAAyB,EAAE;QADlB,aAAQ,GAAR,QAAQ,CAAW;QAC5B,iBAAY,GAAZ,YAAY,CAAe;QALrC,0FAA0F;QACzE,eAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;IAKrD,CAAC;IAEJ,QAAQ,CAAC,KAAe;QACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,IAAI,CAAI,OAAe,EAAE,MAAc,EAAE,IAAe;QAC5D,MAAM,GAAG,GAAG,GAAG,OAAO,IAAI,MAAM,EAAE,CAAC;QACnC,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACtD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QAEpC,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CACrC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,OAAO,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,IAAI,SAAS,IAAI,CAAC,CAAC,KAAK,CAAC,CACvG,CAAC;QACF,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,GAAG,EAAE,wBAAwB,OAAO,IAAI,MAAM,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,oGAAoG;QACpG,mGAAmG;QACnG,mGAAmG;QACnG,MAAM,YAAY,GAAG,CAAC,EAAa,EAAuB,EAAE,CAC1D,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/D,MAAM,OAAO,GACX,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;YAC3E,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,SAAS,CAAC,GAAG,EAAE,wBAAwB,OAAO,IAAI,MAAM,2BAA2B,CAAC,CAAC;QACjG,CAAC;QACD,IAAI,OAAO,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/E,MAAM,IAAI,SAAS,CAAC,GAAG,EAAE,yBAAyB,OAAO,IAAI,MAAM,EAAE,CAAC,CAAC;QACzE,CAAC;QACD,kGAAkG;QAClG,kGAAkG;QAClG,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,IAAI,kBAAkB,OAAO,CAAC,MAAM,QAAQ,OAAO,IAAI,MAAM,EAAE,EAAE,IAAI,CAAC,CAAC;QAC5H,CAAC;QACD,mGAAmG;QACnG,sDAAsD;QACtD,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;QAC7B,OAAO,CAAC,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAE,QAA6B,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAM,CAAC;IACjG,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,gBAAgB;IAC3B,YAA6B,SAAiB,GAAG;QAApB,WAAM,GAAN,MAAM,CAAc;IAAG,CAAC;IAErD,KAAK,CAAC,IAAI,CAAI,OAAe,EAAE,MAAc;QAC3C,MAAM,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,IAAI,CAAC,MAAM,QAAQ,OAAO,IAAI,MAAM,EAAE,CAAC,CAAC;IACrF,CAAC;CACF"}

package/dist/postgrest-fetch.d.ts

@@ -0,0 +1,231 @@
+import { type Fixture } from './mock.js';
+/**
+ * A fake `fetch`, PostgREST-shaped, for injecting into `createClient(url, key, { global: { fetch } })`
+ * (or `createBrowserClient`, which forwards the same option) — one layer BELOW where today's lagoon
+ * stubs sit.
+ *
+ * WHY THIS EXISTS. A lagoon stub today replaces a whole service module by hand, which means the
+ * module's OWN logic — orchestration, derived visibility rules, period math, whatever a real function
+ * does beyond "read a table" — never runs in the lagoon at all. Nobody notices, because there is
+ * nothing to notice: the swap is silent by construction. Swapping one layer down, at the wire, lets
+ * every repository and service function run FOR REAL, everywhere — the lagoon, a runtime check, a
+ * Playwright test — answered by synthetic data instead of synthetic logic.
+ *
+ * WHAT IT DOES NOT DO. This is not a PostgREST clone. It supports exactly the operators a real
+ * project's client-side code was found to use (`eq`, `is`, `gte`, `lt`, `in`, `not.is.null`, a
+ * two-clause `or=`, `order`, `limit`/`offset`, `select` as flat columns/`*`/one embed shape passed
+ * through verbatim, `.single()`/`.maybeSingle()` via `Accept: vnd.pgrst.object+json`, `count=exact`,
+ * writes with `Prefer: return=representation|minimal`, and `rpc`). A query shape outside that set is
+ * an UNSCOPED REQUEST (see below), not a silent wrong answer — the fixture author is meant to notice
+ * and extend the fake, not have it guess.
+ */
+export interface PostgrestTable {
+    /**
+     * Row data, filtered/sorted/paginated generically per request — this table's whole content.
+     *
+     * A plain array for a static fixture; a FUNCTION when the initial content needs to react to a
+     * scenario's seed (`seededValue`, as `services-club-feed.ts` already does for the module-swap
+     * stubs). A remount re-runs the READ, not the module — a table computed once at import time would
+     * answer every later scenario with the first one's seed, same failure club-feed's own comment
+     * documents. Called fresh on every GET, same as `FixtureResponse.response` already is.
+     */
+    rows: Record<string, unknown>[] | (() => Record<string, unknown>[]);
+}
+export interface PostgrestFetchOptions {
+    /** Origin the fake answers for; requests to any other origin are UNSCOPED (see `recordUnscoped`). */
+    baseUrl?: string;
+    /** One entry per table the fake can read/write. Absent table = every read/write on it is unscoped. */
+    tables?: Record<string, PostgrestTable>;
+    /**
+     * RPC results/failures and WRITE results/failures, and — the reason `after` exists — read failures
+     * you want injected on top of the generic table engine (`{ service: table, method: 'select',
+     * status, after }`) without hand-writing the whole read path. Resolved through `MockTransport`, so
+     * `after`/`match`/`roles` all apply exactly as documented there.
+     */
+    fixtures?: Fixture[];
+    /** `auth.getUser()` / `auth.getSession()` stand-ins — most apps route auth through their own client
+     *  and never reach here, but two direct callers are common enough to be worth a first-class slot. */
+    auth?: {
+        user?: unknown;
+        session?: unknown;
+    };
+    /**
+     * Same-origin application routes this fake answers — a Next.js `app/api/**` handler, a Rails
+     * controller, anything the app calls with a RELATIVE url.
+     *
+     * These do not arrive through the database client, so they only reach here via `installFakeFetch`.
+     * Declared as prefixes rather than assumed, because intercepting every same-origin request would
+     * swallow the dev server's own traffic — HMR, assets, source maps — and a lagoon that cannot load
+     * its own modules is a worse failure than an unanswered route.
+     *
+     * Answered from `fixtures` keyed by PATH: `{ service: '/api/admin/announcement', method: 'GET' }`.
+     */
+    appRoutes?: string[];
+}
+/** One request the fake could not answer from a declared table/fixture — the thing a check reports. */
+export interface UnscopedRequest {
+    method: string;
+    path: string;
+    /** `table:<name>` / `rpc:<name>` / `auth:<name>` / `unparsed` — what the fake tried to resolve. */
+    target: string;
+    reason: string;
+}
+/** Read back (and optionally clear) everything recorded since the page loaded or the last read. */
+export declare function readUnscopedRequests(clear?: boolean): UnscopedRequest[];
+/**
+ * Requests the fake DELEGATED that then failed — an app route nobody stubbed, most often.
+ *
+ * Read alongside the unscoped list: unscoped means "the fake saw it and had nothing for it", this
+ * means "the fake never claimed it and the real answer was an error". Both say the island is standing
+ * on something that is not there; they differ only in whether `appRoutes`/`baseUrl` reached it.
+ */
+export declare function readUnansweredRequests(clear?: boolean): {
+    method: string;
+    url: string;
+    status: number;
+    why: string;
+}[];
+export declare function readFakeFetchRequestCount(clear?: boolean): number;
+/** Which tables (and how they were used) and which RPCs an island actually reached. */
+export interface DataReach {
+    tables: Record<string, string[]>;
+    rpcs: string[];
+    /** Edge / serverless functions invoked (`functions.invoke`). */
+    functions: string[];
+    /** Same-origin application routes called, as `GET /api/…`. */
+    routes: string[];
+    /**
+     * The same reach, split by WHO asked, in the vocabulary a declaration uses.
+     *
+     * Keys are `island:<tag>`, `source:<id>`, or `unattributed`; values are entries like
+     * `table:shots(select)`, `rpc:accept_shots`, `fn:notify`, `route:GET /api/x`. The aggregate above
+     * answers "what did this screen touch"; this answers "who has to have declared it", which is the
+     * only form a check can compare — an island's reach is its own `contract.ambient`, a source's is
+     * `reaches` on its `sources` entry, and charging one to the other would report a correct
+     * declaration as a violation.
+     */
+    by: Record<string, string[]>;
+}
+/**
+ * THE CALLS THEMSELVES — what was asked, with what, and what came back.
+ *
+ * `DataReach` above is a SET of names: it answers "did this screen touch `team_schedules`", which is
+ * the question a DECLARATION asks. It cannot answer "did my save actually send the new hour", and
+ * that is the question a person asks when a screen appears to do nothing.
+ *
+ * WHY THIS HAS TO EXIST HERE. Intercepting `fetch` is the point of the lagoon, and the side effect is
+ * that the browser's own Network panel shows NOTHING: no request is made, so no tool that watches the
+ * network can see the app's traffic. motu removed the standard instrument, so motu owes the
+ * replacement — the same argument `traced()`/`provenance` already makes one layer up, for host
+ * modules ("the lagoon shows the result and never the question").
+ *
+ * IT PROVES THE CLIENT HALF ONLY, and the panel that renders it should say so. A request leaving with
+ * the right payload cannot tell you the refetch happened, that the response was merged, or that the
+ * screen re-rendered. It is the diagnosis for "nothing happened" — the write fired and the read did
+ * not change — not evidence that a feature works.
+ */
+export interface WireCall {
+    /** Monotonic, so a UI can order and de-duplicate without trusting the clock. */
+    seq: number;
+    at: number;
+    /** The declaration's own spelling: `rpc:set_session_agenda`, `table:teams(select)`, `fn:x`. */
+    target: string;
+    /** The HTTP verb, for the table calls where it is the difference between a read and a write. */
+    method: string;
+    /**
+     * THE ADDRESS, as it was actually written — `/rest/v1/shots?select=*&club_id=eq.11`.
+     *
+     * `target` is the DECLARATION's spelling of the same call, which is what a check compares against
+     * an `ambient` entry; it is deliberately lossy (`table:shots(select)`) and cannot answer the
+     * question a person asks when a screen is wrong, which is "what did it actually ask for". Origin
+     * stripped: every row here shares it, so it would be 40 characters of noise per line.
+     */
+    url?: string;
+    /** `island:<tag>`, `source:<id>` or `unattributed` — the same attribution `data-reach` uses. */
+    by: string;
+    /**
+     * WHAT THE PERSON DID, when a call can be traced to it — the accessible name of the control they
+     * pressed, and how many milliseconds earlier.
+     *
+     * `by` answers "which declaration should account for this", which is what a CHECK needs. It is
+     * also `unattributed` for most real calls, because a source fetches outside any island's window —
+     * so on the screen where you just pressed Enregistrer, every row says `unattributed` and none of
+     * them says WHY it happened. This is the other axis, and it is the one a person reads: the nine
+     * rows a save produced, grouped under the button that produced them.
+     */
+    gesture?: string;
+    /**
+     * WHICH PRESS, not which label. Every button on this screen is called "Enregistrer" — the séance's
+     * agenda, the commitment banner, the settings dialog — so grouping by the label merged two separate
+     * actions into one run and reported the second as part of the first. An id per press cannot.
+     */
+    gestureId?: number;
+    /** What was sent: an RPC's arguments, a write's row, a read's query string. Truncated. */
+    request?: unknown;
+    status?: number;
+    /** A SUMMARY, never the body: a row count, or the error. Bodies are unbounded and mostly noise. */
+    response?: string;
+}
+/** Notified whenever an intercepted call is recorded. Returns an unsubscribe. */
+export declare function subscribeWireCalls(cb: () => void): () => void;
+/**
+ * Say what the person just did, so the calls that follow can be grouped under it.
+ *
+ * Written through a global rather than an import because the DOCK sets it and the dock is a separate
+ * package that this one must not depend on — the same shape `reachOwner` and the request counter
+ * already use. Dev-only by construction: nothing sets it unless the overlay is mounted.
+ */
+export declare function noteGesture(label: string): void;
+/** Every intercepted call, oldest first. Does NOT clear: a panel polls it, and a flow may read it twice. */
+export declare function readWireCalls(): WireCall[];
+export declare function clearWireCalls(): void;
+export declare function readDataReach(clear?: boolean): DataReach;
+export declare function createPostgrestFetch(options?: PostgrestFetchOptions): typeof fetch;
+/** What a fake answers for: the same-origin route prefixes, and the backend origin. */
+export interface WireClaims {
+    appRoutes?: string[];
+    baseUrl?: string;
+}
+/** What `createPostgrestFetch` stamped on a fake — its own claim, not a second copy of it. */
+export declare function fakeFetchClaims(fake: typeof fetch): WireClaims | undefined;
+/**
+ * Patch `globalThis.fetch` so requests the app makes DIRECTLY — not through the database client —
+ * reach the fake too.
+ *
+ * Injecting `global: { fetch }` into `createClient` covers everything that client issues, which is
+ * most of an app's backend traffic and all of its PostgREST and edge-function traffic. It does not
+ * cover a service that calls `fetch('/api/…')` itself, because that is `window.fetch` and the client
+ * was never involved. Those requests are same-origin, so they are invisible to `network-sealed` as
+ * well: they 404 against the dev server, the caller catches it, an empty state renders, and every
+ * check stays green.
+ *
+ * DELEGATES BY DEFAULT. Only paths the fake actually claims are intercepted; everything else — the
+ * dev server's modules, HMR, assets, source maps — goes to the original `fetch` untouched. A lagoon
+ * that cannot load its own bundle would be a far worse failure than an unanswered route, so the
+ * narrow rule is the safe one.
+ *
+ * ONE PATCH, MANY FAKES. This used to guard on a global boolean, so the FIRST caller won and every
+ * later one was a silent no-op — fine while a project had one region with a wire, and wrong the moment
+ * it had two: the second region's routes went to the dev server, 404'd, its islands rendered empty and
+ * nothing said why. Fakes now REGISTER, and the single patch asks each in turn what it claims.
+ *
+ * Idempotent per fake: installing the same one twice leaves one entry, so a hot reload does not build
+ * a chain of patches or a chain of registrations.
+ */
+export declare function installFakeFetch(fake: typeof fetch, options?: WireClaims): void;
+/** Every fake currently installed, in registration order — what a check reads to say who claimed what. */
+export declare function installedFakeFetches(): readonly WireClaims[];
+/** Forget every installed fake and leave the patch in place. For a test, or a lagoon remount. */
+export declare function resetFakeFetches(): void;
+/**
+ * Patch `globalThis.fetch` NOW, with whatever is registered — and whatever registers later.
+ *
+ * Worth being separate from `installFakeFetch` for one reason: a client that captures `globalThis.fetch`
+ * at IMPORT time (`createClient(url, key, { global: { fetch } })` evaluated at module scope) keeps
+ * whatever `fetch` was when its module ran. If the fakes are declared rather than installed by a
+ * top-level side effect, that capture can happen first and the client talks past every fake, silently.
+ * Calling this at the top of the lagoon entry — before any application module is imported — closes it:
+ * the patch is in place from the start and the registry fills in behind it.
+ */
+export declare function armFakeFetch(): void;
+//# sourceMappingURL=postgrest-fetch.d.ts.map

package/dist/postgrest-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgrest-fetch.d.ts","sourceRoot":"","sources":["../src/postgrest-fetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,QAAQ,CAAC;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;CACrE;AAED,MAAM,WAAW,qBAAqB;IACpC,qGAAqG;IACrG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sGAAsG;IACtG,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB;yGACqG;IACrG,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7C;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,mGAAmG;IACnG,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AASD,mGAAmG;AACnG,wBAAgB,oBAAoB,CAAC,KAAK,UAAO,GAAG,eAAe,EAAE,CAKpE;AAcD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,UAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,CAKnH;AAED,wBAAgB,yBAAyB,CAAC,KAAK,UAAO,GAAG,MAAM,CAK9D;AAED,uFAAuF;AACvF,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,gEAAgE;IAChE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;;;;;OASG;IACH,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9B;AAqED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,QAAQ;IACvB,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,+FAA+F;IAC/F,MAAM,EAAE,MAAM,CAAC;IACf,gGAAgG;IAChG,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gGAAgG;IAChG,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAuCD,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAG7D;AAsBD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/C;AAwBD,4GAA4G;AAC5G,wBAAgB,aAAa,IAAI,QAAQ,EAAE,CAG1C;AAED,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED,wBAAgB,aAAa,CAAC,KAAK,UAAO,GAAG,SAAS,CAKrD;AAkPD,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,KAAK,CAgEtF;AAED,uFAAuF;AACvF,MAAM,WAAW,UAAU;IACzB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAID,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,KAAK,GAAG,UAAU,GAAG,SAAS,CAE1E;AA+JD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,KAAK,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAQ/E;AAYD,0GAA0G;AAC1G,wBAAgB,oBAAoB,IAAI,SAAS,UAAU,EAAE,CAE5D;AAED,iGAAiG;AACjG,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAUD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,IAAI,CA8CnC"}