@fougere/core 0.4.0-alpha.0 → 0.5.0-alpha.1

package/src/wire/drift.ts

@@ -0,0 +1,131 @@
+import { Card, type Change, type SchemaDescriptor } from '@fougere/schema';
+import type { IdentityCard } from './call.js';
+
+/**
+ * What separates the copy a consumer holds from what the producer actually serves.
+ *
+ * It lives beside `IdentityCard` and not in `@fougere/testing` for the reason the card
+ * itself does: the subject is the card, and a second reader arrived — the dev panel, which
+ * must not drag a 426 KB faker in to compare two of them.
+ */
+export interface CardDrift {
+  frond: string;
+  /** A door the consumer calls that the producer no longer serves. */
+  missingDoors: string[];
+  /** An operation the consumer calls that the door no longer has. */
+  missingOps: { door: string; ops: string[] }[];
+  /** A shape that moved under a door the consumer still calls. */
+  shapes: { door: string; changes: Change[] }[];
+  /** A fact the consumer subscribes to whose shape moved, or that is gone. */
+  facts: { fact: string; changes: Change[] | 'gone' }[];
+}
+
+/** Every door of a card, by name. */
+function doorsOf(card: IdentityCard, frond: string): Map<string, { ops: Set<string>; schema?: SchemaDescriptor }> {
+  const found = new Map<string, { ops: Set<string>; schema?: SchemaDescriptor }>();
+  for (const one of card.fronds) {
+    if (one.name !== frond) continue;
+    for (const door of one.doors) {
+      found.set(door.name, { ops: new Set(door.ops.map((op) => op.name)), schema: door.schema });
+    }
+  }
+  return found;
+}
+
+function factsOf(card: IdentityCard, frond: string): Map<string, SchemaDescriptor | undefined> {
+  const found = new Map<string, SchemaDescriptor | undefined>();
+  for (const one of card.fronds) {
+    if (one.name !== frond) continue;
+    for (const fact of one.facts ?? []) found.set(fact.name, fact.schema as SchemaDescriptor | undefined);
+  }
+  return found;
+}
+
+/**
+ * What a consumer's synced copy no longer matches in what the producer serves.
+ *
+ * The gap TypeScript cannot see, and the only place the gradient genuinely lies: the code
+ * is identical in-process and split, but one side may have aged. `fougere sync` wrote the
+ * consumer's copy three weeks ago, the producer moved on, and it still compiles —
+ * production is where that is found today. This is what Pact sells; the material was
+ * already here, in `rpc.discover` and in `Card.diff`.
+ *
+ * Read in ONE direction on purpose: what the consumer holds, checked against what is
+ * served. A producer serving MORE than the consumer knows is not drift — it is a producer
+ * that moved forward without breaking anyone, which is the whole point of the order the
+ * repo already states (re-sync the readers, then deploy the sender).
+ */
+export function driftOf(mine: IdentityCard, theirs: IdentityCard, frond: string): CardDrift {
+  const held = doorsOf(mine, frond);
+  const served = doorsOf(theirs, frond);
+  const drift: CardDrift = { frond, missingDoors: [], missingOps: [], shapes: [], facts: [] };
+
+  for (const [name, door] of held) {
+    const there = served.get(name);
+    if (!there) { drift.missingDoors.push(name); continue; }
+
+    const missing = [...door.ops].filter((op) => !there.ops.has(op));
+    if (missing.length > 0) drift.missingOps.push({ door: name, ops: missing.sort() });
+
+    if (door.schema && there.schema) {
+      // `Card.diff` never guesses a rename — a field gone plus a field appeared lands in
+      // `ambiguous`, and only a declaration settles it. Here nobody can declare one, so
+      // the pair is reported as it is and a human reads it.
+      const moved = Card.fromDescriptor(door.schema).diff(Card.fromDescriptor(there.schema));
+      if (moved.changes.length > 0) drift.shapes.push({ door: name, changes: moved.changes });
+    }
+  }
+
+  const heldFacts = factsOf(mine, frond);
+  const servedFacts = factsOf(theirs, frond);
+  for (const [name, shape] of heldFacts) {
+    if (!servedFacts.has(name)) { drift.facts.push({ fact: name, changes: 'gone' }); continue; }
+    const there = servedFacts.get(name);
+    if (!shape || !there) continue;
+    const moved = Card.fromDescriptor(shape).diff(Card.fromDescriptor(there));
+    if (moved.changes.length > 0) drift.facts.push({ fact: name, changes: moved.changes });
+  }
+
+  return drift;
+}
+
+/** Whether anything at all separates the two cards. */
+export function agrees(drift: CardDrift): boolean {
+  return drift.missingDoors.length === 0
+    && drift.missingOps.length === 0
+    && drift.shapes.length === 0
+    && drift.facts.length === 0;
+}
+
+/**
+ * The drift, in the words a deploy needs.
+ *
+ * A fact says the order out loud, because the repo already states it as a rule and
+ * nothing enforced it: a fact is judged strictly, so a reader that has not been re-synced
+ * refuses what the sender now announces.
+ */
+export function explain(drift: CardDrift): string[] {
+  const lines: string[] = [];
+  for (const door of drift.missingDoors) lines.push(`${drift.frond}.${door} — you call it, it is not served`);
+  for (const { door, ops } of drift.missingOps) lines.push(`${drift.frond}.${door} — gone: ${ops.join(', ')}`);
+  for (const { door, changes } of drift.shapes) {
+    for (const change of changes) lines.push(`${drift.frond}.${door} — ${describe(change)}`);
+  }
+  for (const { fact, changes } of drift.facts) {
+    if (changes === 'gone') { lines.push(`${fact} — you subscribe to it, it is no longer announced`); continue; }
+    for (const change of changes) lines.push(`${fact} — ${describe(change)} → re-sync and deploy the readers, THEN the sender`);
+  }
+  return lines;
+}
+
+function describe(change: Change): string {
+  switch (change.kind) {
+    case 'added': return `+ ${change.field}${change.required ? ' (required)' : ''}`;
+    case 'removed': return `- ${change.field}`;
+    case 'renamed': return `${change.from} → ${change.to}`;
+    case 'retyped': return `${change.field}: ${[...change.from].join('|')} → ${[...change.to].join('|')}`;
+    case 'reshaped': return `${change.field}: its bounds moved`;
+    case 'required': return `${change.field}: ${change.from ? 'no longer' : 'now'} required`;
+    case 'restated': return `${change.field}: its ${change.axis} moved`;
+  }
+}

package/src/wire/middleware.ts

@@ -20,7 +20,7 @@ export interface OperationContext {
   /** Extensible bag — middlewares deposit data here (user, permissions, etc.). */
   state: Record<string, unknown>;
   /** Transport-agnostic invocation context (params, query, body, state). */
-  invocation?: import('./invocation.js').InvocationContext;
+  invocation?: import('../contract/Invocation.js').InvocationContext;
 }
 
 export type AppNext = () => Promise<unknown>;

package/dist/boot/Lifecycle.d.ts

@@ -1,4 +0,0 @@
-/** Compatibility module. Prefer AppLifecycle for the process-level lifecycle. */
-export { AppLifecycle, AppLifecycle as Lifecycle, migrating } from './AppLifecycle.js';
-export type { Extension } from './AppLifecycle.js';
-//# sourceMappingURL=Lifecycle.d.ts.map

package/dist/boot/Lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Lifecycle.d.ts","sourceRoot":"","sources":["../../src/boot/Lifecycle.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,EAAE,YAAY,EAAE,YAAY,IAAI,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACvF,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/boot/Lifecycle.js

@@ -1,3 +0,0 @@
-/** Compatibility module. Prefer AppLifecycle for the process-level lifecycle. */
-export { AppLifecycle, AppLifecycle as Lifecycle, migrating } from './AppLifecycle.js';
-//# sourceMappingURL=Lifecycle.js.map

package/dist/boot/Lifecycle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Lifecycle.js","sourceRoot":"","sources":["../../src/boot/Lifecycle.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,EAAE,YAAY,EAAE,YAAY,IAAI,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/scan/scan-cache.d.ts

@@ -1,16 +0,0 @@
-export declare function setCacheRoot(dir: string): void;
-/**
- * The parse of a file, or the parse again if the file changed — the one gesture, so a
- * caller never assembles the pieces.
- *
- * It handed out `hashFile` + `getCached` + `setCached` and every caller wrote the same
- * five lines in the same order; the scanner wrote them three times, once inline inside a
- * `try`. Three assemblies of one question, each free to forget the half that stores.
- *
- * `key` and not the path alone: one file is parsed several ways (its constructor, its
- * methods, its methods with heritage resolved) and each reading is its own entry.
- */
-export declare function cachedParse<T>(key: string, filePath: string, parse: () => Promise<T>): Promise<T>;
-/** Write cache to disk if modified. */
-export declare function flushCache(): void;
-//# sourceMappingURL=scan-cache.d.ts.map

package/dist/scan/scan-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scan-cache.d.ts","sourceRoot":"","sources":["../../src/scan/scan-cache.ts"],"names":[],"mappings":"AAqDA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAG9C;AA2BD;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUvG;AAED,uCAAuC;AACvC,wBAAgB,UAAU,IAAI,IAAI,CAOjC"}

package/dist/scan/scan-cache.js

@@ -1,99 +0,0 @@
-/**
- * A parse kept per file, so an unchanged source never loads TypeScript again.
- *
- * The envelope carries PARSER_VERSION, and a mismatch drops the whole file. The hash
- * answers "did this source change?"; it cannot answer "does the parser still read it the
- * same way?". A parser fix therefore left every unchanged handler serving the OLD parse,
- * indefinitely and without a word — that is how `Crud`'s inherited ops stayed silently
- * underived for weeks, until someone deleted `.fougere/` by hand and the tests went red.
- *
- * Bump PARSER_VERSION whenever the parser's OUTPUT for unchanged source can differ.
- */
-import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Bump when the parser can read unchanged source differently.
- *
- * 2 — `handler-parser` unwraps a class returned through a call/assertion, so a mixin
- *     like `asCrudConstructor(class { … })` yields its methods again.
- * 3 — parsed array types carry `arrayDepth`, used to distinguish a presenter page
- *     returning scalar fields from one returning list fields.
- */
-// 4 — the parse became a pair (methods + unresolvedHeritage); a v3 entry
-//     would answer with an array and lose the half that reports what it could not open.
-// 5 — a method carried `readOnly`, read off its body. REMOVED (2026-08-16): it answered
-//     "does this touch storage", not "is this a read", so a read that wrote an audit row
-//     was published as a mutation. The number stays taken; going back to 4 would revive
-//     a v4 cache written before 5, which is the same shape but not the same history.
-// 7 — parsed types carry checked, alias-resolved meaning and distinguish `undefined`
-//     from `null`; a v6 entry contains only the syntax that happened to be written.
-const PARSER_VERSION = 7;
-let root = process.cwd();
-let cache = null;
-let dirty = false;
-function cachePath() {
-    return join(root, '.fougere', 'scan-cache.json');
-}
-export function setCacheRoot(dir) {
-    root = dir;
-    cache = null;
-}
-function load() {
-    if (cache)
-        return cache;
-    const path = cachePath();
-    if (existsSync(path)) {
-        try {
-            const file = JSON.parse(readFileSync(path, 'utf-8'));
-            // A stamp from another parser is not stale data to refresh entry by entry — every
-            // entry in the file was produced by it. Drop the lot; the next scan is cold once.
-            if (file.parser === PARSER_VERSION && file.entries) {
-                cache = file.entries;
-                return cache;
-            }
-        }
-        catch {
-            // Corrupted cache — start fresh
-        }
-    }
-    cache = {};
-    return cache;
-}
-function hashFile(filePath) {
-    const content = readFileSync(filePath, 'utf-8');
-    return createHash('sha1').update(content).digest('hex').slice(0, 16);
-}
-/**
- * The parse of a file, or the parse again if the file changed — the one gesture, so a
- * caller never assembles the pieces.
- *
- * It handed out `hashFile` + `getCached` + `setCached` and every caller wrote the same
- * five lines in the same order; the scanner wrote them three times, once inline inside a
- * `try`. Three assemblies of one question, each free to forget the half that stores.
- *
- * `key` and not the path alone: one file is parsed several ways (its constructor, its
- * methods, its methods with heritage resolved) and each reading is its own entry.
- */
-export async function cachedParse(key, filePath, parse) {
-    const hash = hashFile(filePath);
-    const store = load();
-    const entry = store[key];
-    if (entry && entry.hash === hash)
-        return entry.data;
-    const data = await parse();
-    store[key] = { hash, data };
-    dirty = true;
-    return data;
-}
-/** Write cache to disk if modified. */
-export function flushCache() {
-    if (!dirty || !cache)
-        return;
-    const path = cachePath();
-    mkdirSync(join(root, '.fougere'), { recursive: true });
-    const file = { parser: PARSER_VERSION, entries: cache };
-    writeFileSync(path, JSON.stringify(file, null, 2));
-    dirty = false;
-}
-//# sourceMappingURL=scan-cache.js.map

package/dist/scan/scan-cache.js.map

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

package/dist/wire/invocation.d.ts

@@ -1,4 +0,0 @@
-/** Compatibility entry point. New code imports the invocation value from contract. */
-export { Invocation, EMPTY_INVOCATION, canonicalInvocation, } from '../contract/Invocation.js';
-export type { InvocationContext, InvocationInput, } from '../contract/Invocation.js';
-//# sourceMappingURL=invocation.d.ts.map

package/dist/wire/invocation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invocation.d.ts","sourceRoot":"","sources":["../../src/wire/invocation.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,iBAAiB,EACjB,eAAe,GAChB,MAAM,2BAA2B,CAAC"}

package/dist/wire/invocation.js

@@ -1,3 +0,0 @@
-/** Compatibility entry point. New code imports the invocation value from contract. */
-export { Invocation, EMPTY_INVOCATION, canonicalInvocation, } from '../contract/Invocation.js';
-//# sourceMappingURL=invocation.js.map

package/dist/wire/invocation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"invocation.js","sourceRoot":"","sources":["../../src/wire/invocation.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,2BAA2B,CAAC"}

package/src/boot/Lifecycle.ts

@@ -1,3 +0,0 @@
-/** Compatibility module. Prefer AppLifecycle for the process-level lifecycle. */
-export { AppLifecycle, AppLifecycle as Lifecycle, migrating } from './AppLifecycle.js';
-export type { Extension } from './AppLifecycle.js';

package/src/scan/scan-cache.ts

@@ -1,115 +0,0 @@
-/**
- * A parse kept per file, so an unchanged source never loads TypeScript again.
- *
- * The envelope carries PARSER_VERSION, and a mismatch drops the whole file. The hash
- * answers "did this source change?"; it cannot answer "does the parser still read it the
- * same way?". A parser fix therefore left every unchanged handler serving the OLD parse,
- * indefinitely and without a word — that is how `Crud`'s inherited ops stayed silently
- * underived for weeks, until someone deleted `.fougere/` by hand and the tests went red.
- *
- * Bump PARSER_VERSION whenever the parser's OUTPUT for unchanged source can differ.
- */
-import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * Bump when the parser can read unchanged source differently.
- *
- * 2 — `handler-parser` unwraps a class returned through a call/assertion, so a mixin
- *     like `asCrudConstructor(class { … })` yields its methods again.
- * 3 — parsed array types carry `arrayDepth`, used to distinguish a presenter page
- *     returning scalar fields from one returning list fields.
- */
-// 4 — the parse became a pair (methods + unresolvedHeritage); a v3 entry
-//     would answer with an array and lose the half that reports what it could not open.
-// 5 — a method carried `readOnly`, read off its body. REMOVED (2026-08-16): it answered
-//     "does this touch storage", not "is this a read", so a read that wrote an audit row
-//     was published as a mutation. The number stays taken; going back to 4 would revive
-//     a v4 cache written before 5, which is the same shape but not the same history.
-// 7 — parsed types carry checked, alias-resolved meaning and distinguish `undefined`
-//     from `null`; a v6 entry contains only the syntax that happened to be written.
-const PARSER_VERSION = 7;
-
-interface CacheEntry {
-  hash: string;
-  data: unknown;
-}
-
-interface CacheFile {
-  parser: number;
-  entries: Record<string, CacheEntry>;
-}
-
-type CacheData = Record<string, CacheEntry>;
-
-let root = process.cwd();
-let cache: CacheData | null = null;
-let dirty = false;
-
-function cachePath(): string {
-  return join(root, '.fougere', 'scan-cache.json');
-}
-
-export function setCacheRoot(dir: string): void {
-  root = dir;
-  cache = null;
-}
-
-function load(): CacheData {
-  if (cache) return cache;
-  const path = cachePath();
-  if (existsSync(path)) {
-    try {
-      const file = JSON.parse(readFileSync(path, 'utf-8')) as Partial<CacheFile>;
-      // A stamp from another parser is not stale data to refresh entry by entry — every
-      // entry in the file was produced by it. Drop the lot; the next scan is cold once.
-      if (file.parser === PARSER_VERSION && file.entries) {
-        cache = file.entries;
-        return cache;
-      }
-    } catch {
-      // Corrupted cache — start fresh
-    }
-  }
-  cache = {};
-  return cache;
-}
-
-function hashFile(filePath: string): string {
-  const content = readFileSync(filePath, 'utf-8');
-  return createHash('sha1').update(content).digest('hex').slice(0, 16);
-}
-
-/**
- * The parse of a file, or the parse again if the file changed — the one gesture, so a
- * caller never assembles the pieces.
- *
- * It handed out `hashFile` + `getCached` + `setCached` and every caller wrote the same
- * five lines in the same order; the scanner wrote them three times, once inline inside a
- * `try`. Three assemblies of one question, each free to forget the half that stores.
- *
- * `key` and not the path alone: one file is parsed several ways (its constructor, its
- * methods, its methods with heritage resolved) and each reading is its own entry.
- */
-export async function cachedParse<T>(key: string, filePath: string, parse: () => Promise<T>): Promise<T> {
-  const hash = hashFile(filePath);
-  const store = load();
-  const entry = store[key];
-  if (entry && entry.hash === hash) return entry.data as T;
-
-  const data = await parse();
-  store[key] = { hash, data };
-  dirty = true;
-  return data;
-}
-
-/** Write cache to disk if modified. */
-export function flushCache(): void {
-  if (!dirty || !cache) return;
-  const path = cachePath();
-  mkdirSync(join(root, '.fougere'), { recursive: true });
-  const file: CacheFile = { parser: PARSER_VERSION, entries: cache };
-  writeFileSync(path, JSON.stringify(file, null, 2));
-  dirty = false;
-}

package/src/wire/invocation.ts

@@ -1,10 +0,0 @@
-/** Compatibility entry point. New code imports the invocation value from contract. */
-export {
-  Invocation,
-  EMPTY_INVOCATION,
-  canonicalInvocation,
-} from '../contract/Invocation.js';
-export type {
-  InvocationContext,
-  InvocationInput,
-} from '../contract/Invocation.js';