looply-cli 0.0.0-stage → 0.2.0

package/dist/declared-response-shape.d.ts

@@ -0,0 +1,93 @@
+/**
+ * WHAT A CLIENT METHOD CLAIMS ITS RESPONSE LOOKS LIKE.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THIS EXISTS BECAUSE A CLIENT CLAIMED TWO FIELDS THAT DO NOT EXIST, AND
+ *    EVERY GATE PASSED.
+ *
+ * `ServerClient.heartbeat` was typed `{ ok: boolean; nextBeatS?: number }`. The
+ * route returns `{ ttlS, refreshS }`. Both declared fields were invented, and
+ * the consequence was not cosmetic: the server publishes `refreshS` precisely so
+ * a presence TTL can be tuned without shipping a new CLI, and no caller could
+ * reach a field its own type did not name.
+ *
+ * ⚠️ NOTHING COULD HAVE SEEN IT. `this.request<T>(…)` makes `T` true by
+ * assertion — the body is `unknown` on the wire, so TypeScript has nothing to
+ * object to. The SDK's boundary check compares PATHS, and the path was right.
+ * The unit specs inject a fake `fetch`, so the client agreed with itself. The
+ * same shape produced the SDK's invented `RunView.outcome` and `SafetyView`.
+ *
+ * So: read what each method DECLARES, and let a test that has a real response in
+ * its hands check the claim against it.
+ *
+ * This is deliberately a small, honest parser. It reports what it could not read
+ * rather than passing over it, because a checker that silently skips is how a
+ * fifth of a corpus disappears under a confident summary line.
+ */
+export type ShapeKind = 
+/** An inline object literal — `this.request<{ a: string; b?: number }>` — the
+ *  form that can be checked against a real response without resolving
+ *  anything. This is also the form every invented field has taken. */
+'literal'
+/** A named type — `this.request<IngestAck>`. Resolving it means resolving
+ *  imports, which this does not attempt. Reported, never silently dropped. */
+ | 'named';
+export interface DeclaredField {
+    name: string;
+    /** `b?: number` — absent from a response is correct, so it is not checkable. */
+    optional: boolean;
+}
+export interface DeclaredShape {
+    /** The client method the call sits in. */
+    method: string;
+    kind: ShapeKind;
+    /** Empty for `named`. */
+    fields: DeclaredField[];
+    /** The type argument exactly as written, for a failure message that can be read. */
+    raw: string;
+    /**
+     * Is the call's result RETURNED as the method's own result, or unwrapped first?
+     *
+     * 🔴 THIS DISTINCTION IS WHAT KEEPS THE CHECK HONEST. `@looply/sdk` writes
+     * `const r = await this.request<{ goal: GoalView }>(...); return r.goal;` — the
+     * declared type is the ENVELOPE, and the method hands back what is inside it.
+     * Holding the envelope's field list against the unwrapped value would fail on
+     * a correct client, and the natural way to make that green again is to weaken
+     * the check until it proves nothing.
+     *
+     * So a shape is only checkable against a method's result when it IS that
+     * result. Measured: the daemon's client returns all 20 directly, the phone all
+     * 34, and the SDK unwraps every literal one it has.
+     */
+    returned: boolean;
+}
+export declare function declaredResponseShapes(src: string): DeclaredShape[];
+/**
+ * The required fields a method claims, or null when the claim is not checkable.
+ *
+ * Null and empty are DIFFERENT and the difference matters: null means "this type
+ * was never read", empty means "read, and it promises nothing". Collapsing them
+ * turns an unchecked method into a passing one.
+ */
+/**
+ * Every field a method DECLARES, split by requiredness — or null when the claim
+ * is not checkable.
+ *
+ * 🔴 REQUIREDNESS DECIDES WHAT ABSENCE MEANS, NOT WHETHER THE FIELD IS REAL.
+ * `requiredFieldsOf` below drops optionals, so an invented OPTIONAL field was
+ * invisible — and the defect that motivated this whole check declared TWO
+ * invented fields, `{ ok: boolean; nextBeatS?: number }`, of which the optional
+ * one would have sailed through. A checker that catches half its own founding
+ * defect is the kind of thing that gets quoted as coverage.
+ *
+ * A client must not claim a field the server never sends, whatever the `?` says.
+ * What `?` legitimately buys is that the field may be ABSENT FROM A GIVEN
+ * RESPONSE — so the caller must say which optionals its fixture does not
+ * exercise, rather than the checker silently excusing all of them.
+ */
+export declare function declaredFieldsOf(shapes: DeclaredShape[], method: string): {
+    required: string[];
+    optional: string[];
+} | null;
+export declare function requiredFieldsOf(shapes: DeclaredShape[], method: string): string[] | null;
+//# sourceMappingURL=declared-response-shape.d.ts.map

package/dist/declared-response-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-response-shape.d.ts","sourceRoot":"","sources":["../src/declared-response-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,MAAM,SAAS;AACnB;;sEAEsE;AACpE,SAAS;AACX;8EAC8E;GAC5E,OAAO,CAAC;AAEZ,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,SAAS,CAAC;IAChB,yBAAyB;IACzB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,oFAAoF;IACpF,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAiFD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,EAAE,CA2CnE;AAED;;;;;;GAMG;AACH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,EAAE,EACvB,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAOnD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAMzF"}

package/dist/declared-response-shape.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * WHAT A CLIENT METHOD CLAIMS ITS RESPONSE LOOKS LIKE.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THIS EXISTS BECAUSE A CLIENT CLAIMED TWO FIELDS THAT DO NOT EXIST, AND
+ *    EVERY GATE PASSED.
+ *
+ * `ServerClient.heartbeat` was typed `{ ok: boolean; nextBeatS?: number }`. The
+ * route returns `{ ttlS, refreshS }`. Both declared fields were invented, and
+ * the consequence was not cosmetic: the server publishes `refreshS` precisely so
+ * a presence TTL can be tuned without shipping a new CLI, and no caller could
+ * reach a field its own type did not name.
+ *
+ * ⚠️ NOTHING COULD HAVE SEEN IT. `this.request<T>(…)` makes `T` true by
+ * assertion — the body is `unknown` on the wire, so TypeScript has nothing to
+ * object to. The SDK's boundary check compares PATHS, and the path was right.
+ * The unit specs inject a fake `fetch`, so the client agreed with itself. The
+ * same shape produced the SDK's invented `RunView.outcome` and `SafetyView`.
+ *
+ * So: read what each method DECLARES, and let a test that has a real response in
+ * its hands check the claim against it.
+ *
+ * This is deliberately a small, honest parser. It reports what it could not read
+ * rather than passing over it, because a checker that silently skips is how a
+ * fifth of a corpus disappears under a confident summary line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declaredResponseShapes = declaredResponseShapes;
+exports.declaredFieldsOf = declaredFieldsOf;
+exports.requiredFieldsOf = requiredFieldsOf;
+/** Reads `<…>` starting at the `<`, respecting nesting. Returns null if unbalanced. */
+function typeArgument(src, openAt) {
+    let depth = 0;
+    for (let i = openAt; i < src.length; i++) {
+        const c = src[i];
+        if (c === '<')
+            depth++;
+        else if (c === '>') {
+            depth--;
+            if (depth === 0)
+                return { text: src.slice(openAt + 1, i), end: i };
+        }
+    }
+    return null;
+}
+/** The nearest enclosing `  name(` above `at`. */
+function enclosingMethod(src, at) {
+    const before = src.slice(0, at);
+    const lines = before.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        // Two-space indent, an identifier, an open paren: a class method. Deliberately
+        // not matching `if (`/`for (` — those are keywords, excluded below.
+        const m = /^ {2}(?:async )?([A-Za-z_$][\w$]*)\s*\(/.exec(lines[i].replace('\r', ''));
+        if (m && !['if', 'for', 'while', 'switch', 'catch', 'return'].includes(m[1]))
+            return m[1];
+    }
+    return '<unknown>';
+}
+/**
+ * Is there a `|` or `&` at the OUTERMOST level?
+ *
+ * 🔴 "ANYWHERE IN THE STRING" IS THE WRONG TEST, AND IT WAS THE FIRST ONE
+ * WRITTEN. `{ answeredAt: string | null }` is a perfectly ordinary object
+ * literal whose FIELD happens to be nullable; rejecting it as a union skipped a
+ * method that was checkable, and skipping is the silent direction. `{ a } | null`
+ * really is a union, and its `|` sits at depth 0 after the closing brace.
+ */
+function unionAtTopLevel(raw) {
+    let depth = 0;
+    for (const c of raw) {
+        if (c === '{' || c === '(' || c === '[' || c === '<')
+            depth++;
+        else if (c === '}' || c === ')' || c === ']' || c === '>')
+            depth--;
+        else if ((c === '|' || c === '&') && depth === 0)
+            return true;
+    }
+    return false;
+}
+/** Splits `a: string; b?: { c: number }` on top-level `;` only. */
+/**
+ * Splits a type literal into its members.
+ *
+ * 🔴 THREE SEPARATORS, NOT ONE, AND THE MISSING TWO WERE LIVE DEFECTS.
+ * This split on `;` alone, so:
+ *   `{ a: string, b: number }`  -> ONE member, and only `a` was read
+ *   a member on its own line with no `;` -> collapsed into its predecessor
+ * Both are ordinary TypeScript that survives prettier, and both silently
+ * shrank the declared field set -- which makes an INVENTED field invisible,
+ * because a field the parser never saw cannot be reported as missing.
+ *
+ * A newline at depth 0 is also a separator. A member whose type sits on the
+ * next line then splits into `a:` and its type; the first still matches the
+ * field pattern and the second simply does not, so nothing is lost.
+ */
+function topLevelMembers(body) {
+    const out = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (c === '{' || c === '(' || c === '[' || c === '<')
+            depth++;
+        else if (c === '}' || c === ')' || c === ']' || c === '>')
+            depth--;
+        else if (depth === 0 && (c === ';' || c === ',' || c === '\n')) {
+            out.push(body.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(body.slice(start));
+    return out.map((m) => m.trim()).filter((m) => m.length > 0);
+}
+function declaredResponseShapes(src) {
+    const shapes = [];
+    const needle = 'this.request<';
+    let from = 0;
+    for (;;) {
+        const at = src.indexOf(needle, from);
+        if (at === -1)
+            break;
+        const openAt = at + needle.length - 1;
+        const arg = typeArgument(src, openAt);
+        if (!arg) {
+            from = at + needle.length;
+            continue;
+        }
+        from = arg.end;
+        const raw = arg.text.trim();
+        const method = enclosingMethod(src, at);
+        // The text between the start of the line and the call. `return this.request<`
+        // and `return await this.request<` are returned; `const r = await ...` is not.
+        const lineStart = src.lastIndexOf('\n', at) + 1;
+        const returned = /^\s*return\s+(await\s+)?$/.test(src.slice(lineStart, at));
+        // 🔴 ONLY A PURE OBJECT LITERAL IS CHECKABLE. A union (`X | null`), an
+        // intersection (`A & { b }`) or a named type is reported as `named` rather
+        // than half-parsed — a field list guessed out of a union is worse than
+        // admitting the type was not read.
+        const isPureLiteral = raw.startsWith('{') && raw.endsWith('}') && !unionAtTopLevel(raw);
+        if (!isPureLiteral) {
+            shapes.push({ method, kind: 'named', fields: [], raw, returned });
+            continue;
+        }
+        const fields = [];
+        for (const member of topLevelMembers(raw.slice(1, -1))) {
+            // `readonly` is a modifier; a property name may be quoted. Both are
+            // idiomatic and both used to drop the field silently.
+            const m = /^(?:readonly\s+)?(?:\'([^']+)'|\"([^"]+)\"|([A-Za-z_$][\w$]*))\s*(\?)?\s*:/.exec(member);
+            // Groups: 1 single-quoted name, 2 double-quoted, 3 bare identifier,
+            // 4 the optional marker.
+            if (m)
+                fields.push({ name: (m[1] ?? m[2] ?? m[3]), optional: m[4] === '?' });
+        }
+        shapes.push({ method, kind: 'literal', fields, raw, returned });
+    }
+    return shapes;
+}
+/**
+ * The required fields a method claims, or null when the claim is not checkable.
+ *
+ * Null and empty are DIFFERENT and the difference matters: null means "this type
+ * was never read", empty means "read, and it promises nothing". Collapsing them
+ * turns an unchecked method into a passing one.
+ */
+/**
+ * Every field a method DECLARES, split by requiredness — or null when the claim
+ * is not checkable.
+ *
+ * 🔴 REQUIREDNESS DECIDES WHAT ABSENCE MEANS, NOT WHETHER THE FIELD IS REAL.
+ * `requiredFieldsOf` below drops optionals, so an invented OPTIONAL field was
+ * invisible — and the defect that motivated this whole check declared TWO
+ * invented fields, `{ ok: boolean; nextBeatS?: number }`, of which the optional
+ * one would have sailed through. A checker that catches half its own founding
+ * defect is the kind of thing that gets quoted as coverage.
+ *
+ * A client must not claim a field the server never sends, whatever the `?` says.
+ * What `?` legitimately buys is that the field may be ABSENT FROM A GIVEN
+ * RESPONSE — so the caller must say which optionals its fixture does not
+ * exercise, rather than the checker silently excusing all of them.
+ */
+function declaredFieldsOf(shapes, method) {
+    const shape = shapes.find((s) => s.method === method);
+    if (!shape || shape.kind !== 'literal' || !shape.returned)
+        return null;
+    return {
+        required: shape.fields.filter((f) => !f.optional).map((f) => f.name),
+        optional: shape.fields.filter((f) => f.optional).map((f) => f.name),
+    };
+}
+function requiredFieldsOf(shapes, method) {
+    const shape = shapes.find((s) => s.method === method);
+    if (!shape || shape.kind !== 'literal')
+        return null;
+    // An unwrapped envelope describes the WIRE, not this method's result.
+    if (!shape.returned)
+        return null;
+    return shape.fields.filter((f) => !f.optional).map((f) => f.name);
+}
+//# sourceMappingURL=declared-response-shape.js.map

package/dist/declared-response-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-response-shape.js","sourceRoot":"","sources":["../src/declared-response-shape.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;AAyHH,wDA2CC;AAyBD,4CAUC;AAED,4CAMC;AArKD,uFAAuF;AACvF,SAAS,YAAY,CAAC,GAAW,EAAE,MAAc;IAC/C,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG;YAAE,KAAK,EAAE,CAAC;aAClB,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACnB,KAAK,EAAE,CAAC;YACR,IAAI,KAAK,KAAK,CAAC;gBAAE,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;QACrE,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,kDAAkD;AAClD,SAAS,eAAe,CAAC,GAAW,EAAE,EAAU;IAC9C,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAChC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjC,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,+EAA+E;QAC/E,oEAAoE;QACpE,MAAM,CAAC,GAAG,yCAAyC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;QACtF,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAE,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC,CAAE,CAAC;IAC9F,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,GAAW;IAClC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;QACpB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;YAAE,KAAK,EAAE,CAAC;aACzD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;YAAE,KAAK,EAAE,CAAC;aAC9D,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,KAAK,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;IAChE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,mEAAmE;AACnE;;;;;;;;;;;;;;GAcG;AACH,SAAS,eAAe,CAAC,IAAY;IACnC,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;YAAE,KAAK,EAAE,CAAC;aACzD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;YAAE,KAAK,EAAE,CAAC;aAC9D,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;YAC/D,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;YAC/B,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;QAChB,CAAC;IACH,CAAC;IACD,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5B,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,SAAgB,sBAAsB,CAAC,GAAW;IAChD,MAAM,MAAM,GAAoB,EAAE,CAAC;IACnC,MAAM,MAAM,GAAG,eAAe,CAAC;IAC/B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,SAAS,CAAC;QACR,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACrC,IAAI,EAAE,KAAK,CAAC,CAAC;YAAE,MAAM;QACrB,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACtC,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,IAAI,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC;YAC1B,SAAS;QACX,CAAC;QACD,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC;QACf,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACxC,8EAA8E;QAC9E,+EAA+E;QAC/E,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;QAChD,MAAM,QAAQ,GAAG,2BAA2B,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;QAE5E,uEAAuE;QACvE,2EAA2E;QAC3E,uEAAuE;QACvE,mCAAmC;QACnC,MAAM,aAAa,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QACxF,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;YAClE,SAAS;QACX,CAAC;QAED,MAAM,MAAM,GAAoB,EAAE,CAAC;QACnC,KAAK,MAAM,MAAM,IAAI,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACvD,oEAAoE;YACpE,sDAAsD;YACtD,MAAM,CAAC,GAAG,4EAA4E,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACpG,oEAAoE;YACpE,yBAAyB;YACzB,IAAI,CAAC;gBAAE,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,gBAAgB,CAC9B,MAAuB,EACvB,MAAc;IAEd,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IACtD,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IACvE,OAAO;QACL,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACpE,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;KACpE,CAAC;AACJ,CAAC;AAED,SAAgB,gBAAgB,CAAC,MAAuB,EAAE,MAAc;IACtE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IACtD,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACpD,sEAAsE;IACtE,IAAI,CAAC,KAAK,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IACjC,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACpE,CAAC"}

package/dist/declared-surfaces.d.ts

@@ -0,0 +1,16 @@
+import type { LooplyConfig } from './config';
+import type { GoalBinding } from './goal-ownership';
+/**
+ * THE SURFACES A RUN DECLARES — the one place the run reads `Goal.surfaces`.
+ *
+ * Read from the goal the run is BOUND to, as the daemon's mirror holds it,
+ * and only when the project asked for surfaces (`run.surfaces: true`). Off
+ * means no lease is ever taken — not "taken and ignored": the acquire is not
+ * called at all, so a project that never asked has no new file, no new
+ * failure mode and no new refusal. Unbound means the same.
+ *
+ * Extracted from `run-cmd.ts` so the seam can be held to a test that feeds
+ * it a real mirror and takes a real lease with what it answers.
+ */
+export declare function declaredSurfacesFor(config: Pick<LooplyConfig, 'run'>, binding: GoalBinding): readonly string[];
+//# sourceMappingURL=declared-surfaces.d.ts.map

package/dist/declared-surfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-surfaces.d.ts","sourceRoot":"","sources":["../src/declared-surfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,SAAS,MAAM,EAAE,CAE9G"}

package/dist/declared-surfaces.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declaredSurfacesFor = declaredSurfacesFor;
+/**
+ * THE SURFACES A RUN DECLARES — the one place the run reads `Goal.surfaces`.
+ *
+ * Read from the goal the run is BOUND to, as the daemon's mirror holds it,
+ * and only when the project asked for surfaces (`run.surfaces: true`). Off
+ * means no lease is ever taken — not "taken and ignored": the acquire is not
+ * called at all, so a project that never asked has no new file, no new
+ * failure mode and no new refusal. Unbound means the same.
+ *
+ * Extracted from `run-cmd.ts` so the seam can be held to a test that feeds
+ * it a real mirror and takes a real lease with what it answers.
+ */
+function declaredSurfacesFor(config, binding) {
+    return config.run.surfaces === true && binding.kind === 'bound' ? (binding.goal.surfaces ?? []) : [];
+}
+//# sourceMappingURL=declared-surfaces.js.map

package/dist/declared-surfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-surfaces.js","sourceRoot":"","sources":["../src/declared-surfaces.ts"],"names":[],"mappings":";;AAeA,kDAEC;AAdD;;;;;;;;;;;GAWG;AACH,SAAgB,mBAAmB,CAAC,MAAiC,EAAE,OAAoB;IACzF,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACvG,CAAC"}

package/dist/depends-review.d.ts

@@ -0,0 +1,113 @@
+import { type DependsFacts, type DependsVerdict, type ProposedDependency, type TrustedActionContext } from '@looply/core';
+import { type EdgeApprovalCapability, type FiledEdge } from './edge-approval';
+/**
+ * PUTTING A PROPOSED EDGE TO THE FENCE, WITH FACTS SOMEBODY ACTUALLY READ.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE FENCE TAKES FACTS AND CANNOT GO AND GET THEM. `dependsVerdict` is pure
+ * — goal versions, source hashes and the graph all arrive as arguments — which
+ * is what makes staleness testable without a server and is also why, until this
+ * file existed, nothing ever ran it: the daemon held the edges and had no
+ * assembled answer to judge them against.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * ⚠️ AND THE FACTS ARE READ ONCE, FOR ALL THE EDGES IN A TICK.
+ *
+ * Reading them per edge would let two edges in one cadence be judged against
+ * two different worlds — the second one stale by a change the first one caused,
+ * or worse, not stale because a change landed between the two reads. One
+ * snapshot, every edge, one answer about one moment.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 NOTHING HERE APPLIES ANYTHING. An accepted edge is returned for a person;
+ * writing one would be a provider's suggestion reaching the graph through a
+ * daemon tick, which is the whole thing the fence and the approval path exist
+ * to prevent.
+ */
+export interface DependsReviewDeps {
+    /** Every goal of the project, with the fields the fence compares. */
+    goals(): Promise<DependsFacts['goals']>;
+    /** The content hash each source id currently holds. */
+    sourceShas(): Promise<ReadonlyMap<string, string>>;
+    readonly projectId: string;
+}
+export interface ReviewedEdge {
+    readonly edge: ProposedDependency;
+    readonly verdict: DependsVerdict;
+}
+export interface DependsReview {
+    readonly reviewed: readonly ReviewedEdge[];
+    /**
+     * 🔴 THE FACTS COULD NOT BE ASSEMBLED, SO NOTHING WAS JUDGED. Not an empty
+     * review — an absent one. A caller that read `reviewed: []` as "no edges
+     * survived" would be reporting a refusal nobody made.
+     */
+    readonly because: string | null;
+}
+/**
+ * Judge every edge one tick produced, against one reading of the world.
+ *
+ * ⚠️ `citationsVerified: true` IS TRUE BY CONSTRUCTION HERE AND IS STILL PASSED
+ * RATHER THAN ASSUMED. `toDependsProposals` only returns edges from records
+ * whose verdict was `ok`, so the fence's first check cannot fail on this path —
+ * but it is a real guard for every other path, and hard-coding it inside the
+ * fence would remove it for all of them to save one argument here.
+ */
+export declare function reviewEdges(edges: readonly ProposedDependency[], deps: DependsReviewDeps): Promise<DependsReview>;
+/**
+ * The lines a person reads.
+ *
+ * 🔴 AN ACCEPTED EDGE IS THE ONE THAT NEEDS THE LOUDEST CAVEAT, not the
+ * quietest line. "Accepted" here means "it passed every check a machine can
+ * make" and nothing else; the edge is not in the graph and will not be until
+ * somebody puts it there.
+ */
+export declare function reportReview(review: DependsReview, out: (line: string) => void): void;
+/**
+ * ⚠️ HOW MANY NEW QUESTIONS ONE CADENCE MAY RAISE.
+ *
+ * 🔴 NOT A HYPOTHETICAL BOUND. `proposalsForTick` re-reads every record for
+ * every goal it iterates, so an edge accepted three cadences ago is in
+ * `tick.edges` on this cadence too — and on every cadence after it. Without a
+ * cap, ten pending edges would be ten network calls per heartbeat, for ever.
+ * The approval surface deduplicates on the client reference so none of them
+ * would create a second question; the cost is entirely in making the calls.
+ *
+ * One, like `MAX_ASKS_PER_TICK` beside it, and for the same reason: a heartbeat
+ * should wait for one thing, not for a queue.
+ */
+export declare const MAX_EDGE_FILINGS_PER_TICK = 1;
+export interface FilingOutcome {
+    readonly filed: readonly FiledEdge[];
+    /** Accepted, and left for a later cadence because of the cap. */
+    readonly deferred: number;
+}
+/**
+ * File the accepted edges of one review, within the cadence's bound.
+ *
+ * 🔴 ONLY `accepted` REACHES ANYBODY, and `fileEdge` is what enforces that —
+ * this function does not re-implement the judgement, it only decides how many
+ * of them one cadence may raise, and which ones.
+ *
+ * 🔴 `turn` DECIDES WHICH, AND WITHOUT IT THE BOUND STARVED EVERY EDGE BUT ONE.
+ * `accepted` arrives in the same order every cadence, and an edge that is
+ * already waiting for a decision stays accepted until somebody decides it — so
+ * `slice(0, max)` re-filed that one edge on every heartbeat (a deduplicated
+ * call, asking nobody anything) and the edge behind it was never raised at all.
+ * MEASURED live (LIVE-2): "already waiting for a decision: Make gol_…ejz@2 wait
+ * for gol_…e57@2" and "1 more accepted edge(s) wait for a later cadence", every
+ * cadence, while the fence had accepted the second edge long before. Starting
+ * the window at `turn` keeps the bound exactly as it was — `max` calls per
+ * cadence — and gives every accepted edge its turn within `accepted.length`
+ * cadences. The caller advances it, the way `autonomyTick` gets `rotation`.
+ */
+export declare function fileReviewed(review: DependsReview, ctx: TrustedActionContext, approvals: EdgeApprovalCapability, max?: number, turn?: number): Promise<FilingOutcome>;
+/**
+ * The lines a person reads about what was raised.
+ *
+ * ⚠️ A DEFERRED EDGE IS SAID OUT LOUD. Silence would make a cap look like a
+ * judgement: "nothing else was accepted" and "the rest wait for the next
+ * cadence" are completely different, and only one of them is about the edges.
+ */
+export declare function reportFiling(outcome: FilingOutcome, out: (line: string) => void): void;
+//# sourceMappingURL=depends-review.d.ts.map

package/dist/depends-review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depends-review.d.ts","sourceRoot":"","sources":["../src/depends-review.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EAA2B,KAAK,sBAAsB,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEvG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IACxC,uDAAuD;IACvD,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,SAAS,kBAAkB,EAAE,EACpC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,aAAa,CAAC,CAexB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAQrF;AAID;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,oBAAoB,EACzB,SAAS,EAAE,sBAAsB,EACjC,GAAG,GAAE,MAAkC,EACvC,IAAI,SAAI,GACP,OAAO,CAAC,aAAa,CAAC,CASxB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAKtF"}

package/dist/depends-review.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_EDGE_FILINGS_PER_TICK = void 0;
+exports.reviewEdges = reviewEdges;
+exports.reportReview = reportReview;
+exports.fileReviewed = fileReviewed;
+exports.reportFiling = reportFiling;
+const core_1 = require("@looply/core");
+const edge_approval_1 = require("./edge-approval");
+/**
+ * Judge every edge one tick produced, against one reading of the world.
+ *
+ * ⚠️ `citationsVerified: true` IS TRUE BY CONSTRUCTION HERE AND IS STILL PASSED
+ * RATHER THAN ASSUMED. `toDependsProposals` only returns edges from records
+ * whose verdict was `ok`, so the fence's first check cannot fail on this path —
+ * but it is a real guard for every other path, and hard-coding it inside the
+ * fence would remove it for all of them to save one argument here.
+ */
+async function reviewEdges(edges, deps) {
+    if (edges.length === 0)
+        return { reviewed: [], because: null };
+    let facts;
+    try {
+        const [goals, sourceShas] = await Promise.all([deps.goals(), deps.sourceShas()]);
+        facts = { projectId: deps.projectId, goals, sourceShas, citationsVerified: true };
+    }
+    catch (e) {
+        return {
+            reviewed: [],
+            because: `the facts to judge ${edges.length} proposed edge(s) could not be read (${e.message}), so none was judged`,
+        };
+    }
+    return { reviewed: edges.map((edge) => ({ edge, verdict: (0, core_1.dependsVerdict)(edge, facts) })), because: null };
+}
+/**
+ * The lines a person reads.
+ *
+ * 🔴 AN ACCEPTED EDGE IS THE ONE THAT NEEDS THE LOUDEST CAVEAT, not the
+ * quietest line. "Accepted" here means "it passed every check a machine can
+ * make" and nothing else; the edge is not in the graph and will not be until
+ * somebody puts it there.
+ */
+function reportReview(review, out) {
+    if (review.because !== null) {
+        out(`depends : ${review.because}`);
+        return;
+    }
+    for (const { verdict } of review.reviewed) {
+        out(`depends : ${(0, core_1.describeDependsVerdict)(verdict)}`);
+    }
+}
+/* ────────────────────────────────── putting it to a person ── */
+/**
+ * ⚠️ HOW MANY NEW QUESTIONS ONE CADENCE MAY RAISE.
+ *
+ * 🔴 NOT A HYPOTHETICAL BOUND. `proposalsForTick` re-reads every record for
+ * every goal it iterates, so an edge accepted three cadences ago is in
+ * `tick.edges` on this cadence too — and on every cadence after it. Without a
+ * cap, ten pending edges would be ten network calls per heartbeat, for ever.
+ * The approval surface deduplicates on the client reference so none of them
+ * would create a second question; the cost is entirely in making the calls.
+ *
+ * One, like `MAX_ASKS_PER_TICK` beside it, and for the same reason: a heartbeat
+ * should wait for one thing, not for a queue.
+ */
+exports.MAX_EDGE_FILINGS_PER_TICK = 1;
+/**
+ * File the accepted edges of one review, within the cadence's bound.
+ *
+ * 🔴 ONLY `accepted` REACHES ANYBODY, and `fileEdge` is what enforces that —
+ * this function does not re-implement the judgement, it only decides how many
+ * of them one cadence may raise, and which ones.
+ *
+ * 🔴 `turn` DECIDES WHICH, AND WITHOUT IT THE BOUND STARVED EVERY EDGE BUT ONE.
+ * `accepted` arrives in the same order every cadence, and an edge that is
+ * already waiting for a decision stays accepted until somebody decides it — so
+ * `slice(0, max)` re-filed that one edge on every heartbeat (a deduplicated
+ * call, asking nobody anything) and the edge behind it was never raised at all.
+ * MEASURED live (LIVE-2): "already waiting for a decision: Make gol_…ejz@2 wait
+ * for gol_…e57@2" and "1 more accepted edge(s) wait for a later cadence", every
+ * cadence, while the fence had accepted the second edge long before. Starting
+ * the window at `turn` keeps the bound exactly as it was — `max` calls per
+ * cadence — and gives every accepted edge its turn within `accepted.length`
+ * cadences. The caller advances it, the way `autonomyTick` gets `rotation`.
+ */
+async function fileReviewed(review, ctx, approvals, max = exports.MAX_EDGE_FILINGS_PER_TICK, turn = 0) {
+    const accepted = review.reviewed.filter((r) => r.verdict.kind === 'accepted');
+    const start = accepted.length === 0 ? 0 : ((turn % accepted.length) + accepted.length) % accepted.length;
+    const inTurn = [...accepted.slice(start), ...accepted.slice(0, start)];
+    const filed = [];
+    for (const { edge, verdict } of inTurn.slice(0, max)) {
+        filed.push(await (0, edge_approval_1.fileEdge)(edge, verdict, ctx, approvals));
+    }
+    return { filed, deferred: Math.max(0, accepted.length - max) };
+}
+/**
+ * The lines a person reads about what was raised.
+ *
+ * ⚠️ A DEFERRED EDGE IS SAID OUT LOUD. Silence would make a cap look like a
+ * judgement: "nothing else was accepted" and "the rest wait for the next
+ * cadence" are completely different, and only one of them is about the edges.
+ */
+function reportFiling(outcome, out) {
+    for (const f of outcome.filed)
+        out(`depends : ${(0, edge_approval_1.describeFiled)(f)}`);
+    if (outcome.deferred > 0) {
+        out(`depends : ${outcome.deferred} more accepted edge(s) wait for a later cadence — one is raised per heartbeat`);
+    }
+}
+//# sourceMappingURL=depends-review.js.map

package/dist/depends-review.js.map

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