@loomwork/classify 0.0.0-stage → 0.1.1

package/dist/external.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.externalized = externalized;
+exports.isExternalized = isExternalized;
+exports.externalizedPaths = externalizedPaths;
+const classify_1 = require("./classify");
+// ── ADR 0046 — the `externalized()` marker ────────────────────────────────────
+//
+// Orthogonal to the secret/sensitive/internal taxonomy: that axis says HOW sensitive a field
+// is; this one says WHERE its value is stored — externalized to a content store, with the log
+// keeping only a reference. A field can be both (a large AND sensitive document: externalize
+// the bytes, and encrypt them in the content store). Because it is a separate axis, it has its
+// own registry rather than a fourth DataClass.
+//
+// A non-invasive WeakMap keeps the marker from mutating the Zod schema (same instance returned,
+// validation untouched), exactly like the classification registry.
+const externalRegistry = new WeakMap();
+/**
+ * Mark a field `externalized` — its value is moved to a content store on append and the log
+ * keeps a content-addressed reference (ADR 0046). Returns the SAME schema (validation
+ * unchanged). Marking an object externalizes its whole subtree as one blob.
+ */
+function externalized(schema) {
+    externalRegistry.set(schema, true);
+    return schema;
+}
+/** Whether a schema was marked {@link externalized} (through transparent wrappers is handled by the walker). */
+function isExternalized(schema) {
+    return typeof schema === "object" && schema !== null && externalRegistry.get(schema) === true;
+}
+/**
+ * The dot-paths of every `externalized()`-marked field in a schema (declaration order,
+ * deterministic). A marked object is reported at its own path as a unit.
+ */
+function externalizedPaths(schema) {
+    return (0, classify_1.collectMarkedPaths)(schema, (node) => externalRegistry.get(node) === true ? true : undefined).map((m) => m.path);
+}
+//# sourceMappingURL=external.js.map

package/dist/external.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"external.js","sourceRoot":"","sources":["../src/external.ts"],"names":[],"mappings":";;AAqBA,oCAGC;AAGD,wCAEC;AAMD,8CAIC;AAtCD,yCAAgD;AAEhD,iFAAiF;AACjF,EAAE;AACF,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,+FAA+F;AAC/F,+CAA+C;AAC/C,EAAE;AACF,gGAAgG;AAChG,mEAAmE;AAEnE,MAAM,gBAAgB,GAAG,IAAI,OAAO,EAAgB,CAAC;AAErD;;;;GAIG;AACH,SAAgB,YAAY,CAAyB,MAAS;IAC5D,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACnC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,gHAAgH;AAChH,SAAgB,cAAc,CAAC,MAAe;IAC5C,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;AAChG,CAAC;AAED;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,MAAoB;IACpD,OAAO,IAAA,6BAAkB,EAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CACzC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CACvD,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACvB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { classify, classOf, collectClassifiedPaths, collectMarkedPaths, internal, pathsOfClass, secret, sensitive, strictest, } from "./classify";
+export type { ClassifiedPath, DataClass } from "./classify";
+export { externalized, externalizedPaths, isExternalized } from "./external";
+export { TAINT_SCAN_EXCEEDED_ORIGIN, TAINT_SCAN_MAX_DEPTH, TAINT_SCAN_MAX_NODES, isTainted, nestedTaintOrigin, taintOriginLabel, TAINT_ORIGIN_LABEL_MAX, scanTaint, tainted, taintOf, unwrapTainted, } from "./taint";
+export type { Taint, TaintScan, TaintScanOptions, TaintedValue } from "./taint";
+export { REDACTED, maskPaths } from "./redact";
+export { expandPaths, hasWildcard } from "./expand";
+export { collectUnreachableMarks } from "./unreachable";
+export type { UnreachableMark } from "./unreachable";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,OAAO,EACP,sBAAsB,EACtB,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,SAAS,EACT,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,SAAS,EACT,OAAO,EACP,OAAO,EACP,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUnreachableMarks = exports.hasWildcard = exports.expandPaths = exports.maskPaths = exports.REDACTED = exports.unwrapTainted = exports.taintOf = exports.tainted = exports.scanTaint = exports.TAINT_ORIGIN_LABEL_MAX = exports.taintOriginLabel = exports.nestedTaintOrigin = exports.isTainted = exports.TAINT_SCAN_MAX_NODES = exports.TAINT_SCAN_MAX_DEPTH = exports.TAINT_SCAN_EXCEEDED_ORIGIN = exports.isExternalized = exports.externalizedPaths = exports.externalized = exports.strictest = exports.sensitive = exports.secret = exports.pathsOfClass = exports.internal = exports.collectMarkedPaths = exports.collectClassifiedPaths = exports.classOf = exports.classify = void 0;
+var classify_1 = require("./classify");
+Object.defineProperty(exports, "classify", { enumerable: true, get: function () { return classify_1.classify; } });
+Object.defineProperty(exports, "classOf", { enumerable: true, get: function () { return classify_1.classOf; } });
+Object.defineProperty(exports, "collectClassifiedPaths", { enumerable: true, get: function () { return classify_1.collectClassifiedPaths; } });
+Object.defineProperty(exports, "collectMarkedPaths", { enumerable: true, get: function () { return classify_1.collectMarkedPaths; } });
+Object.defineProperty(exports, "internal", { enumerable: true, get: function () { return classify_1.internal; } });
+Object.defineProperty(exports, "pathsOfClass", { enumerable: true, get: function () { return classify_1.pathsOfClass; } });
+Object.defineProperty(exports, "secret", { enumerable: true, get: function () { return classify_1.secret; } });
+Object.defineProperty(exports, "sensitive", { enumerable: true, get: function () { return classify_1.sensitive; } });
+Object.defineProperty(exports, "strictest", { enumerable: true, get: function () { return classify_1.strictest; } });
+var external_1 = require("./external");
+Object.defineProperty(exports, "externalized", { enumerable: true, get: function () { return external_1.externalized; } });
+Object.defineProperty(exports, "externalizedPaths", { enumerable: true, get: function () { return external_1.externalizedPaths; } });
+Object.defineProperty(exports, "isExternalized", { enumerable: true, get: function () { return external_1.isExternalized; } });
+var taint_1 = require("./taint");
+Object.defineProperty(exports, "TAINT_SCAN_EXCEEDED_ORIGIN", { enumerable: true, get: function () { return taint_1.TAINT_SCAN_EXCEEDED_ORIGIN; } });
+Object.defineProperty(exports, "TAINT_SCAN_MAX_DEPTH", { enumerable: true, get: function () { return taint_1.TAINT_SCAN_MAX_DEPTH; } });
+Object.defineProperty(exports, "TAINT_SCAN_MAX_NODES", { enumerable: true, get: function () { return taint_1.TAINT_SCAN_MAX_NODES; } });
+Object.defineProperty(exports, "isTainted", { enumerable: true, get: function () { return taint_1.isTainted; } });
+Object.defineProperty(exports, "nestedTaintOrigin", { enumerable: true, get: function () { return taint_1.nestedTaintOrigin; } });
+Object.defineProperty(exports, "taintOriginLabel", { enumerable: true, get: function () { return taint_1.taintOriginLabel; } });
+Object.defineProperty(exports, "TAINT_ORIGIN_LABEL_MAX", { enumerable: true, get: function () { return taint_1.TAINT_ORIGIN_LABEL_MAX; } });
+Object.defineProperty(exports, "scanTaint", { enumerable: true, get: function () { return taint_1.scanTaint; } });
+Object.defineProperty(exports, "tainted", { enumerable: true, get: function () { return taint_1.tainted; } });
+Object.defineProperty(exports, "taintOf", { enumerable: true, get: function () { return taint_1.taintOf; } });
+Object.defineProperty(exports, "unwrapTainted", { enumerable: true, get: function () { return taint_1.unwrapTainted; } });
+var redact_1 = require("./redact");
+Object.defineProperty(exports, "REDACTED", { enumerable: true, get: function () { return redact_1.REDACTED; } });
+Object.defineProperty(exports, "maskPaths", { enumerable: true, get: function () { return redact_1.maskPaths; } });
+var expand_1 = require("./expand");
+Object.defineProperty(exports, "expandPaths", { enumerable: true, get: function () { return expand_1.expandPaths; } });
+Object.defineProperty(exports, "hasWildcard", { enumerable: true, get: function () { return expand_1.hasWildcard; } });
+var unreachable_1 = require("./unreachable");
+Object.defineProperty(exports, "collectUnreachableMarks", { enumerable: true, get: function () { return unreachable_1.collectUnreachableMarks; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,uCAUoB;AATlB,oGAAA,QAAQ,OAAA;AACR,mGAAA,OAAO,OAAA;AACP,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,oGAAA,QAAQ,OAAA;AACR,wGAAA,YAAY,OAAA;AACZ,kGAAA,MAAM,OAAA;AACN,qGAAA,SAAS,OAAA;AACT,qGAAA,SAAS,OAAA;AAGX,uCAA6E;AAApE,wGAAA,YAAY,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AAAE,0GAAA,cAAc,OAAA;AACxD,iCAYiB;AAXf,mHAAA,0BAA0B,OAAA;AAC1B,6GAAA,oBAAoB,OAAA;AACpB,6GAAA,oBAAoB,OAAA;AACpB,kGAAA,SAAS,OAAA;AACT,0GAAA,iBAAiB,OAAA;AACjB,yGAAA,gBAAgB,OAAA;AAChB,+GAAA,sBAAsB,OAAA;AACtB,kGAAA,SAAS,OAAA;AACT,gGAAA,OAAO,OAAA;AACP,gGAAA,OAAO,OAAA;AACP,sGAAA,aAAa,OAAA;AAGf,mCAA+C;AAAtC,kGAAA,QAAQ,OAAA;AAAE,mGAAA,SAAS,OAAA;AAC5B,mCAAoD;AAA3C,qGAAA,WAAW,OAAA;AAAE,qGAAA,WAAW,OAAA;AACjC,6CAAwD;AAA/C,sHAAA,uBAAuB,OAAA"}

package/dist/redact.d.ts

@@ -0,0 +1,4 @@
+/** The value an egress-masked field is replaced by (structure kept, value gone). */
+export declare const REDACTED: "[redacted]";
+export declare function maskPaths(root: unknown, paths: readonly string[], mask?: unknown): unknown;
+//# sourceMappingURL=redact.d.ts.map

package/dist/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../src/redact.ts"],"names":[],"mappings":"AAUA,oFAAoF;AACpF,eAAO,MAAM,QAAQ,EAAG,YAAqB,CAAC;AAc9C,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,GAAE,OAAkB,GACvB,OAAO,CA6BT"}

package/dist/redact.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDACTED = void 0;
+exports.maskPaths = maskPaths;
+const expand_1 = require("./expand");
+// ── K10-R6 — the shared egress-masking primitive ──────────────────────────────
+//
+// One structural path-masker, used by every egress surface (telemetry adapters, agent-surface
+// surfaces, the CLI). It replaces the value at each dot-path with a mask, copying only the
+// spine it touches (structural sharing elsewhere) and never mutating the caller's object.
+// Absent paths are skipped, so masking a payload that doesn't carry a marked field is a
+// no-op on that field. Lives here in `@loomwork/classify` — the neutral home the classification
+// consumers already depend on — so no surface package depends on another.
+/** The value an egress-masked field is replaced by (structure kept, value gone). */
+exports.REDACTED = "[redacted]";
+/**
+ * Return a copy of `root` with each dot-path's value replaced by `mask`. A dot-path always
+ * roots at an object (an array/primitive root has nothing to address), so those are returned
+ * as-is. Paths are applied independently; a shared prefix is copied once.
+ */
+/** Copy one spine node, preserving arrays. */
+function shallowCopy(value) {
+    return Array.isArray(value)
+        ? [...value]
+        : { ...value };
+}
+function maskPaths(root, paths, mask = exports.REDACTED) {
+    if (typeof root !== "object" || root === null || Array.isArray(root))
+        return root;
+    const out = { ...root };
+    // `[]` segments are resolved against the concrete value first (#260); a path without one
+    // passes through untouched, so pre-existing behaviour is unchanged.
+    for (const path of (0, expand_1.hasWildcard)(paths) ? (0, expand_1.expandPaths)(root, paths) : paths) {
+        const segs = path.split(".");
+        let src = root;
+        let dst = out;
+        let reachable = true;
+        for (let i = 0; i < segs.length - 1; i++) {
+            const seg = segs[i];
+            const child = src[seg];
+            if (typeof child !== "object" || child === null) {
+                reachable = false;
+                break;
+            }
+            // Copy this spine node once (first path to reach it); later paths sharing the prefix
+            // descend into the already-copied node.
+            // Copy arrays AS arrays. `{ ...array }` would yield an object with numeric keys —
+            // harmless while paths never crossed arrays, corrupting now that they do.
+            if (dst[seg] === child)
+                dst[seg] = shallowCopy(child);
+            src = child;
+            dst = dst[seg];
+        }
+        const leaf = segs[segs.length - 1];
+        if (reachable && Object.hasOwn(src, leaf))
+            dst[leaf] = mask;
+    }
+    return out;
+}
+//# sourceMappingURL=redact.js.map

package/dist/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.js","sourceRoot":"","sources":["../src/redact.ts"],"names":[],"mappings":";;;AAyBA,8BAiCC;AA1DD,qCAAoD;AACpD,iFAAiF;AACjF,EAAE;AACF,8FAA8F;AAC9F,2FAA2F;AAC3F,0FAA0F;AAC1F,wFAAwF;AACxF,gGAAgG;AAChG,0EAA0E;AAE1E,oFAAoF;AACvE,QAAA,QAAQ,GAAG,YAAqB,CAAC;AAE9C;;;;GAIG;AACH,8CAA8C;AAC9C,SAAS,WAAW,CAAC,KAAa;IAChC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACzB,CAAC,CAAE,CAAC,GAAG,KAAK,CAAwC;QACpD,CAAC,CAAC,EAAE,GAAI,KAAiC,EAAE,CAAC;AAChD,CAAC;AAED,SAAgB,SAAS,CACvB,IAAa,EACb,KAAwB,EACxB,OAAgB,gBAAQ;IAExB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAClF,MAAM,GAAG,GAA4B,EAAE,GAAI,IAAgC,EAAE,CAAC;IAC9E,yFAAyF;IACzF,oEAAoE;IACpE,KAAK,MAAM,IAAI,IAAI,IAAA,oBAAW,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAA,oBAAW,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;QACzE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,GAAG,GAAG,IAA+B,CAAC;QAC1C,IAAI,GAAG,GAAG,GAAG,CAAC;QACd,IAAI,SAAS,GAAG,IAAI,CAAC;QACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAW,CAAC;YAC9B,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;YACvB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBAChD,SAAS,GAAG,KAAK,CAAC;gBAClB,MAAM;YACR,CAAC;YACD,qFAAqF;YACrF,wCAAwC;YACxC,kFAAkF;YAClF,0EAA0E;YAC1E,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK;gBAAE,GAAG,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAe,CAAC,CAAC;YAChE,GAAG,GAAG,KAAgC,CAAC;YACvC,GAAG,GAAG,GAAG,CAAC,GAAG,CAA4B,CAAC;QAC5C,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAW,CAAC;QAC7C,IAAI,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/taint.d.ts

@@ -0,0 +1,85 @@
+/** Where a tainted value came from — an origin label, e.g. `mcp:acme/chart`. */
+export interface Taint {
+    /**
+     * Human-meaningful provenance, chosen by the producer. It is rendered into
+     * the fence around the content, so treat it as untrusted display text: it
+     * frequently contains a third-party-controlled fragment (a tool name, a peer
+     * id) and is escaped at the point of use, never trusted as markup.
+     */
+    origin: string;
+}
+/** A value carrying its own provenance. Plain JSON — survives the log unchanged. */
+export interface TaintedValue<T = unknown> {
+    __loomTainted: Taint;
+    value: T;
+}
+/**
+ * Wrap a value as untrusted, recording where it came from.
+ *
+ * Apply this at INGRESS — the moment content crosses into the system from a
+ * party that is not the operator. Tainting later is guesswork, and tainting
+ * never is how third-party text ends up in a system prompt.
+ *
+ * Re-tainting an already-tainted value keeps the ORIGINAL origin: provenance
+ * records where content entered, and a re-wrap would let a later, more
+ * flattering label overwrite the true one.
+ */
+export declare function tainted<T>(value: T, origin: string): TaintedValue<T>;
+/** Whether a value carries taint. Structural, so it survives a JSON round-trip. */
+export declare function isTainted(value: unknown): value is TaintedValue;
+/** The provenance on a value, or `undefined` when it carries none. */
+export declare function taintOf(value: unknown): Taint | undefined;
+/**
+ * The inner value, discarding provenance. Non-tainted values pass through.
+ *
+ * Deliberately loud. Unwrapping is legitimate and often necessary — parsing a
+ * tainted JSON payload, indexing a tainted record — but every call is a place
+ * where provenance stops travelling. Unwrap to COMPUTE with content; never
+ * unwrap on the way to a prompt, which is the one path the taint exists to
+ * govern. Nothing can stop you; the point is that the call site is visible.
+ */
+export declare function unwrapTainted<T>(value: TaintedValue<T> | T): T;
+/** Bounds of a {@link scanTaint} walk. */
+export interface TaintScanOptions {
+    /** Deepest nesting visited (the root is depth 0). Default {@link TAINT_SCAN_MAX_DEPTH}. */
+    maxDepth?: number;
+    /** Most object/array nodes visited. Default {@link TAINT_SCAN_MAX_NODES}. */
+    maxNodes?: number;
+}
+/** Default nesting bound of {@link scanTaint}. */
+export declare const TAINT_SCAN_MAX_DEPTH = 64;
+/** Default node bound of {@link scanTaint}. */
+export declare const TAINT_SCAN_MAX_NODES = 100000;
+/** The origin reported when a scan hit its bound and could not prove the value clean. */
+export declare const TAINT_SCAN_EXCEEDED_ORIGIN = "unknown:taint-scan-bound-exceeded";
+/** What {@link scanTaint} found. */
+export interface TaintScan {
+    /** Distinct origins of every wrapper found, in discovery order. */
+    readonly origins: readonly string[];
+    /** The walk hit a bound before it finished: the value is NOT proven clean. */
+    readonly exceeded: boolean;
+    /** `origins` is non-empty or `exceeded` - the value must be treated as untrusted. */
+    readonly tainted: boolean;
+}
+/**
+ * Walk `value` for taint wrappers at ANY depth. Iterative (no recursion, so a 100k-deep JSON cannot
+ * blow the stack), cycle-safe, and bounded by depth and node count. FAILS CLOSED: when a bound is hit
+ * the result is `exceeded: true` and `tainted: true`, because "too big to look at" is not "clean".
+ * Binary views are skipped (they cannot hold a wrapper). Pure: the value is never modified.
+ */
+export declare function scanTaint(value: unknown, options?: TaintScanOptions): TaintScan;
+/** Most distinct origins named in a joined label; the rest are counted (`+N more`). */
+export declare const TAINT_ORIGIN_LABEL_MAX = 8;
+/**
+ * The label for a {@link TaintScan}, or `undefined` when it is clean. The first
+ * {@link TAINT_ORIGIN_LABEL_MAX} distinct origins are joined (`a, b`) and the rest counted
+ * (`+N more`), so a value stuffed with forged wrappers cannot make a megabyte label that is then
+ * journaled and fenced. A bound hit adds {@link TAINT_SCAN_EXCEEDED_ORIGIN}.
+ */
+export declare function taintOriginLabel(scan: TaintScan): string | undefined;
+/**
+ * The origin label for a value that may hold nested taint, or `undefined` when it is provably clean
+ * (see {@link taintOriginLabel}).
+ */
+export declare function nestedTaintOrigin(value: unknown, options?: TaintScanOptions): string | undefined;
+//# sourceMappingURL=taint.d.ts.map

package/dist/taint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taint.d.ts","sourceRoot":"","sources":["../src/taint.ts"],"names":[],"mappings":"AA0BA,gFAAgF;AAChF,MAAM,WAAW,KAAK;IACpB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oFAAoF;AACpF,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,aAAa,EAAE,KAAK,CAAC;IACrB,KAAK,EAAE,CAAC,CAAC;CACV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAGpE;AAED,mFAAmF;AACnF,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAS/D;AAED,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,GAAG,SAAS,CAEzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAE9D;AASD,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,kDAAkD;AAClD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,+CAA+C;AAC/C,eAAO,MAAM,oBAAoB,SAAU,CAAC;AAC5C,yFAAyF;AACzF,eAAO,MAAM,0BAA0B,sCAAsC,CAAC;AAE9E,oCAAoC;AACpC,MAAM,WAAW,SAAS;IACxB,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,gBAAqB,GAAG,SAAS,CA6BnF;AAED,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAIxC;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAWpE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,SAAS,CAEhG"}

package/dist/taint.js

@@ -0,0 +1,152 @@
+"use strict";
+// ── The integrity axis — provenance for content the system did not author ────
+//
+// The existing markers are a CONFIDENTIALITY axis (`secret`/`sensitive`/
+// `internal` — what may LEAVE) plus a where-stored axis (`externalized`). This
+// is the third and opposite direction: what may ENTER an instruction position.
+// A third-party MCP tool result, an A2A peer's response, a fetched document —
+// all arrive as ordinary strings, and an ordinary string interpolated into a
+// system prompt is indistinguishable from an instruction the operator wrote.
+//
+// WHY A VALUE WRAPPER AND NOT A SCHEMA MARKER. Confidentiality is a property of
+// a FIELD: `ssn` is sensitive in every execution, forever, so declaring it once
+// at the schema is exactly right. Integrity is a property of a VALUE: the same
+// `summary: string` field is trustworthy when this flow computed it and
+// untrusted when a third-party server returned it, and which one it is cannot be
+// known until runtime. A schema marker would have to guess, and a marker that
+// guesses is worse than none — it reads as coverage. So taint is attached where
+// it is acquired, to the value, by the code that acquired it.
+//
+// The wrapper is plain JSON (`{ __loomTainted, value }`), the same structural
+// shape K10.3's `secretRef` uses, so it survives the log verbatim and a replay
+// hands the effect back a value that is still tainted. The corollary is the
+// honest limit on retrofitting: taint applies to content ingested AFTER a
+// producer starts applying it. An existing log replays exactly as it did, with
+// no taint, because the fact was never recorded — the same argument ADR 0063 D3
+// made about principals.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAINT_ORIGIN_LABEL_MAX = exports.TAINT_SCAN_EXCEEDED_ORIGIN = exports.TAINT_SCAN_MAX_NODES = exports.TAINT_SCAN_MAX_DEPTH = void 0;
+exports.tainted = tainted;
+exports.isTainted = isTainted;
+exports.taintOf = taintOf;
+exports.unwrapTainted = unwrapTainted;
+exports.scanTaint = scanTaint;
+exports.taintOriginLabel = taintOriginLabel;
+exports.nestedTaintOrigin = nestedTaintOrigin;
+/**
+ * Wrap a value as untrusted, recording where it came from.
+ *
+ * Apply this at INGRESS — the moment content crosses into the system from a
+ * party that is not the operator. Tainting later is guesswork, and tainting
+ * never is how third-party text ends up in a system prompt.
+ *
+ * Re-tainting an already-tainted value keeps the ORIGINAL origin: provenance
+ * records where content entered, and a re-wrap would let a later, more
+ * flattering label overwrite the true one.
+ */
+function tainted(value, origin) {
+    if (isTainted(value))
+        return value;
+    return { __loomTainted: { origin }, value };
+}
+/** Whether a value carries taint. Structural, so it survives a JSON round-trip. */
+function isTainted(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const mark = value.__loomTainted;
+    return (typeof mark === "object" &&
+        mark !== null &&
+        typeof mark.origin === "string" &&
+        "value" in value);
+}
+/** The provenance on a value, or `undefined` when it carries none. */
+function taintOf(value) {
+    return isTainted(value) ? value.__loomTainted : undefined;
+}
+/**
+ * The inner value, discarding provenance. Non-tainted values pass through.
+ *
+ * Deliberately loud. Unwrapping is legitimate and often necessary — parsing a
+ * tainted JSON payload, indexing a tainted record — but every call is a place
+ * where provenance stops travelling. Unwrap to COMPUTE with content; never
+ * unwrap on the way to a prompt, which is the one path the taint exists to
+ * govern. Nothing can stop you; the point is that the call site is visible.
+ */
+function unwrapTainted(value) {
+    return isTainted(value) ? value.value : value;
+}
+/** Default nesting bound of {@link scanTaint}. */
+exports.TAINT_SCAN_MAX_DEPTH = 64;
+/** Default node bound of {@link scanTaint}. */
+exports.TAINT_SCAN_MAX_NODES = 100_000;
+/** The origin reported when a scan hit its bound and could not prove the value clean. */
+exports.TAINT_SCAN_EXCEEDED_ORIGIN = "unknown:taint-scan-bound-exceeded";
+/**
+ * Walk `value` for taint wrappers at ANY depth. Iterative (no recursion, so a 100k-deep JSON cannot
+ * blow the stack), cycle-safe, and bounded by depth and node count. FAILS CLOSED: when a bound is hit
+ * the result is `exceeded: true` and `tainted: true`, because "too big to look at" is not "clean".
+ * Binary views are skipped (they cannot hold a wrapper). Pure: the value is never modified.
+ */
+function scanTaint(value, options = {}) {
+    const maxDepth = options.maxDepth ?? exports.TAINT_SCAN_MAX_DEPTH;
+    const maxNodes = options.maxNodes ?? exports.TAINT_SCAN_MAX_NODES;
+    const origins = [];
+    const found = new Set();
+    let exceeded = false;
+    let nodes = 0;
+    const seen = new WeakSet();
+    const stack = [{ v: value, d: 0 }];
+    while (stack.length > 0) {
+        const { v, d } = stack.pop();
+        if (typeof v !== "object" || v === null || seen.has(v) || ArrayBuffer.isView(v))
+            continue;
+        seen.add(v);
+        if (++nodes > maxNodes || d > maxDepth) {
+            exceeded = true;
+            break;
+        }
+        if (isTainted(v)) {
+            const origin = v.__loomTainted.origin;
+            if (!found.has(origin)) {
+                found.add(origin);
+                origins.push(origin);
+            }
+        }
+        for (const child of Array.isArray(v) ? v : Object.values(v)) {
+            if (typeof child === "object" && child !== null)
+                stack.push({ v: child, d: d + 1 });
+        }
+    }
+    return { origins, exceeded, tainted: exceeded || origins.length > 0 };
+}
+/** Most distinct origins named in a joined label; the rest are counted (`+N more`). */
+exports.TAINT_ORIGIN_LABEL_MAX = 8;
+/** Longest single origin kept in a joined label (a forged wrapper can carry a megabyte origin). */
+const TAINT_ORIGIN_MAX_CHARS = 200;
+/**
+ * The label for a {@link TaintScan}, or `undefined` when it is clean. The first
+ * {@link TAINT_ORIGIN_LABEL_MAX} distinct origins are joined (`a, b`) and the rest counted
+ * (`+N more`), so a value stuffed with forged wrappers cannot make a megabyte label that is then
+ * journaled and fenced. A bound hit adds {@link TAINT_SCAN_EXCEEDED_ORIGIN}.
+ */
+function taintOriginLabel(scan) {
+    if (!scan.tainted)
+        return undefined;
+    const shown = scan.origins
+        .slice(0, exports.TAINT_ORIGIN_LABEL_MAX)
+        .map((o) => o.length > TAINT_ORIGIN_MAX_CHARS ? `${o.slice(0, TAINT_ORIGIN_MAX_CHARS)}...` : o);
+    const more = scan.origins.length - shown.length;
+    if (more > 0)
+        shown.push(`+${more} more`);
+    if (scan.exceeded)
+        shown.push(exports.TAINT_SCAN_EXCEEDED_ORIGIN);
+    return shown.join(", ");
+}
+/**
+ * The origin label for a value that may hold nested taint, or `undefined` when it is provably clean
+ * (see {@link taintOriginLabel}).
+ */
+function nestedTaintOrigin(value, options) {
+    return taintOriginLabel(scanTaint(value, options));
+}
+//# sourceMappingURL=taint.js.map

package/dist/taint.js.map

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

package/dist/unreachable.d.ts

@@ -0,0 +1,20 @@
+import type { z } from "zod";
+import { type DataClass } from "./classify";
+/** A classification mark that no dot-path sink can address. */
+export interface UnreachableMark {
+    /**
+     * Dot-path to the mark, with `[]` per array crossing and `<Type>` where an untraversable
+     * container sits — e.g. `"byId.<record>.ssn"`. Not an addressable path; a location.
+     */
+    readonly path: string;
+    readonly dataClass: DataClass;
+    /** The container that blocks it, lowercased without the `Zod` prefix (`record`, `union`, …). */
+    readonly container: string;
+}
+/**
+ * Every classification mark stranded under a container the dot-path sinks cannot address.
+ *
+ * Returns `[]` for marks on objects and arrays — both are traversable, so those marks work.
+ */
+export declare function collectUnreachableMarks(schema: z.ZodTypeAny, prefix?: string): UnreachableMark[];
+//# sourceMappingURL=unreachable.d.ts.map

package/dist/unreachable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreachable.d.ts","sourceRoot":"","sources":["../src/unreachable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,YAAY,CAAC;AAgBrD,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,gGAAgG;IAChG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAwFD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,SAAK,GAAG,eAAe,EAAE,CAE5F"}

package/dist/unreachable.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUnreachableMarks = collectUnreachableMarks;
+const classify_1 = require("./classify");
+/** Unwrap optional/nullable/default/effects, as the classification walker does. */
+function chain(schema) {
+    const nodes = [];
+    let cur = schema;
+    for (let i = 0; i < 100; i++) {
+        nodes.push(cur);
+        const def = cur._def;
+        const typeName = def?.typeName;
+        let next;
+        if (typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "ZodDefault") {
+            next = def?.innerType;
+        }
+        else if (typeName === "ZodEffects") {
+            next = def?.schema;
+        }
+        else {
+            break;
+        }
+        if (next === undefined)
+            break;
+        cur = next;
+    }
+    return { nodes, inner: cur };
+}
+function typeNameOf(node) {
+    return node._def?.typeName;
+}
+function objectShape(node) {
+    const def = node._def;
+    if (def?.typeName !== "ZodObject" || typeof def.shape !== "function")
+        return undefined;
+    return def.shape();
+}
+function arrayElement(node) {
+    const def = node._def;
+    if (def?.typeName !== "ZodArray")
+        return undefined;
+    return def.type;
+}
+/**
+ * Schemas that hold inner schemas the classification walker never descends into. Returns the
+ * children to search for stranded marks, plus the label for the location string.
+ *
+ * `lazy` is deliberately absent: descending a recursive schema to hunt for marks risks
+ * non-termination, and the payoff is small.
+ */
+function opaqueChildren(node) {
+    const def = node._def;
+    const typeName = typeNameOf(node);
+    switch (typeName) {
+        case "ZodRecord":
+        case "ZodMap":
+        case "ZodSet":
+            return {
+                label: typeName.slice(3).toLowerCase(),
+                children: [def?.valueType].filter(Boolean),
+            };
+        case "ZodUnion":
+        case "ZodDiscriminatedUnion": {
+            const options = def?.options;
+            const list = Array.isArray(options)
+                ? options
+                : [...(options?.values?.() ?? [])];
+            return { label: "union", children: list };
+        }
+        case "ZodTuple":
+            return { label: "tuple", children: def?.items ?? [] };
+        case "ZodIntersection":
+            return {
+                label: "intersection",
+                children: [def?.left, def?.right].filter(Boolean),
+            };
+        default:
+            return undefined;
+    }
+}
+function effectiveClass(schema) {
+    for (const node of chain(schema).nodes) {
+        const mark = (0, classify_1.classOf)(node);
+        if (mark !== undefined)
+            return mark;
+    }
+    return undefined;
+}
+/**
+ * Every classification mark stranded under a container the dot-path sinks cannot address.
+ *
+ * Returns `[]` for marks on objects and arrays — both are traversable, so those marks work.
+ */
+function collectUnreachableMarks(schema, prefix = "") {
+    return walk(schema, prefix, undefined);
+}
+function walk(schema, path, blockedBy) {
+    const mark = effectiveClass(schema);
+    if (mark !== undefined && path !== "") {
+        // A mark terminates the walk exactly as it does in `collectMarkedPaths` — a marked object
+        // is a unit — so a mark nested inside a marked one is not double-reported.
+        return blockedBy === undefined ? [] : [{ path, dataClass: mark, container: blockedBy }];
+    }
+    const inner = chain(schema).inner;
+    const element = arrayElement(inner);
+    if (element !== undefined)
+        return walk(element, `${path}[]`, blockedBy);
+    const shape = objectShape(inner);
+    if (shape !== undefined) {
+        const out = [];
+        for (const [key, child] of Object.entries(shape)) {
+            out.push(...walk(child, path === "" ? key : `${path}.${key}`, blockedBy));
+        }
+        return out;
+    }
+    const opaque = opaqueChildren(inner);
+    if (opaque !== undefined) {
+        const out = [];
+        // Everything below here is unreachable — but keep the OUTERMOST blocker, since that is
+        // the one the developer has to restructure.
+        const blocker = blockedBy ?? opaque.label;
+        for (const child of opaque.children) {
+            out.push(...walk(child, `${path}.<${opaque.label}>`, blocker));
+        }
+        return out;
+    }
+    return [];
+}
+//# sourceMappingURL=unreachable.js.map

package/dist/unreachable.js.map

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