@telorun/analyzer 0.64.0 → 0.66.0

package/dist/schema-error-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-error-report.d.ts","sourceRoot":"","sources":["../src/schema-error-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;gDACgD;AAChD,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;CACd;AAWD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAe3D;AAkGD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,EAAE,CAsF5F;AAqHD;;sFAEsF;AACtF,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAaxD;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,EAAE,CAKrF;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAIjF"}

package/dist/schema-error-report.js

@@ -0,0 +1,356 @@
+/**
+ * The one renderer for AJV validation failures.
+ *
+ * Browser-safe and re-imported by the kernel — the split `buildEvalPaths` and
+ * the redaction path parser already use — so a failure is phrased identically
+ * under `telo check` and at runtime. Three implementations used to answer this
+ * (the analyzer's keyword prose, the kernel's raw `instancePath + message`
+ * join, and observed state's own inline variant), so a developer who fixed what
+ * the analyzer told them met a different sentence describing the same thing.
+ *
+ * UNION REDUCTION is the second half. A union must attempt every branch, and
+ * AJV cannot know which one was intended — `discriminator: true` works only
+ * against an explicit OpenAPI-style discriminator property, which would mean
+ * changing what every module's authors write. So branch selection is a
+ * reporting concern and lives here.
+ *
+ * It narrows the error SET, never just the sentence: every consumer maps the
+ * surviving errors to manifest paths to anchor a diagnostic, so reducing at the
+ * prose layer alone would move the soup out of the message and into the
+ * problems list, one entry per branch on a different line.
+ *
+ * Selection is made from the ERRORS ALONE, never from the schema. A branch
+ * whose discriminating key is present emits no complaint at the union's own
+ * instancePath; one whose key is absent says `required`, and one that forbids a
+ * key the value carries says `additionalProperties`. That is the whole signal,
+ * and reading it off the errors is what lets reduction work across a `$ref`
+ * into another registered schema, where navigating to the branch subschema
+ * would mean re-implementing AJV's resolution.
+ */
+const UNION_KEYWORDS = new Set(["anyOf", "oneOf"]);
+/** Keywords a branch raises at the union's OWN instancePath when the value is
+ *  not of that branch's shape at all — as opposed to being that shape and wrong
+ *  further in. These are what make a branch implausible. */
+const SHAPE_KEYWORDS = new Set(["required", "type", "additionalProperties", "enum", "const"]);
+/* ------------------------------------------------------------------ prose */
+export function formatSingleError(err) {
+    const p = err.instancePath || "/";
+    const params = err.params ?? {};
+    switch (err.keyword) {
+        case "additionalProperties":
+            return `${p} must NOT have additional properties ('${params.additionalProperty}' is not allowed)`;
+        case "required":
+            return `${p} is missing required property '${params.missingProperty}'`;
+        case "enum":
+            return `${p} ${err.message ?? "is invalid"} (${params.allowedValues?.join(" | ")})`;
+        case "type":
+            return `${p} must be ${params.type}${describeActual(err)}`;
+        default:
+            return `${p} ${err.message ?? "is invalid"}`;
+    }
+}
+/** ` (got string)`, or nothing when the value is not in hand. AJV carries
+ *  `data` only under `verbose`, and a reducer that navigated the root value
+ *  would have to be given it at every call site; an absent actual type is worth
+ *  less than a wrong one. */
+function describeActual(err) {
+    if (!("data" in err))
+        return "";
+    const d = err.data;
+    if (d === null)
+        return " (got null)";
+    if (Array.isArray(d))
+        return " (got array)";
+    return ` (got ${typeof d})`;
+}
+/* -------------------------------------------------------------- reduction */
+/** The branch index a `schemaPath` sits under, for a union whose own schemaPath
+ *  is `unionPath` (`…/anyOf`): a child is `…/anyOf/<i>/…` and nothing else can
+ *  collide with it. */
+function branchIndexUnder(unionPath, schemaPath) {
+    if (!schemaPath || !schemaPath.startsWith(unionPath + "/"))
+        return undefined;
+    const rest = schemaPath.slice(unionPath.length + 1);
+    const slash = rest.indexOf("/");
+    const head = slash === -1 ? rest : rest.slice(0, slash);
+    const index = Number(head);
+    return Number.isInteger(index) ? index : undefined;
+}
+function instanceDepth(path) {
+    if (!path)
+        return 0;
+    return path.split("/").filter((s) => s !== "").length;
+}
+/**
+ * How the alternatives at a union node are described, one phrase each.
+ *
+ * Read off the complaints made at the union's own node, and deliberately ONE
+ * PHRASE PER MISSING KEY rather than one per error group. AJV inlines most
+ * `$ref` branches and reports them all under the same bare `schemaPath`, so
+ * several branches are genuinely indistinguishable in the error set — joining
+ * their keys into a single phrase would read as one alternative demanding all
+ * of them, which is a claim about the schema that is simply false. Listing them
+ * separately under-specifies a branch that requires two keys at once, and each
+ * clause is still a true necessary condition; asserting a conjunction that does
+ * not exist is not.
+ */
+function describeAlternatives(errors, unionInstancePath) {
+    const own = errors.filter((e) => (e.instancePath || "") === unionInstancePath);
+    const phrases = [];
+    for (const e of own) {
+        if (e.keyword === "required")
+            phrases.push(`one with '${e.params?.missingProperty}'`);
+        else if (e.keyword === "type")
+            phrases.push(`a ${e.params?.type}`);
+        else if (e.keyword === "enum") {
+            phrases.push(`one of ${e.params?.allowedValues?.join(" | ")}`);
+        }
+    }
+    return phrases.length > 0 ? phrases : ["another shape"];
+}
+/** Is this branch a plausible reading of the value — does it accept the value's
+ *  shape at the union node itself, and only disagree further in? */
+function isPlausible(errors, unionInstancePath) {
+    return !errors.some((e) => (e.instancePath || "") === unionInstancePath && SHAPE_KEYWORDS.has(e.keyword ?? ""));
+}
+function isUnder(child, parent) {
+    return parent === "" ? child !== "" : child.startsWith(parent + "/");
+}
+/** The value path one level up, or undefined at the root. `""` is the root, so
+ *  a non-empty path with no separator has the root as its parent. */
+function parentPath(path) {
+    if (path === "")
+        return undefined;
+    const cut = path.lastIndexOf("/");
+    return cut <= 0 ? "" : path.slice(0, cut);
+}
+/**
+ * Replace each failing union with the errors of the branch the author plainly
+ * meant, recursively, outside in.
+ *
+ * Attribution runs to the DEEPEST occurrence that could own an error, which is
+ * what keeps a container's own complaint apart from its child's when both carry
+ * the same `schemaPath`. An occurrence reached through a branch becomes a
+ * candidate branch of its own — it raised nothing at the parent's node, so it is
+ * plausible exactly when the value really did take that shape and fail further
+ * in, and reducing it recursively is what stops an inner union's alternatives
+ * from surviving inside the outer one's selection.
+ */
+export function reduceSchemaErrors(errors) {
+    if (!errors || errors.length === 0)
+        return [];
+    const occurrences = errors
+        .filter((e) => UNION_KEYWORDS.has(e.keyword ?? "") && typeof e.schemaPath === "string")
+        .map((e) => ({
+        error: e,
+        schemaPath: e.schemaPath,
+        instancePath: e.instancePath || "",
+        owned: [],
+        children: [],
+    }));
+    if (occurrences.length === 0)
+        return errors;
+    // The VALUE NODE is the claim, not the schemaPath. A branch written as a
+    // `$ref` is reported by AJV under the TARGET's schemaPath — and AJV inlines
+    // some of them, reporting several branches under one identical path — so
+    // nothing in such an error points back at the union that dispatched to it. A
+    // large union is written exactly that way, a branch per `$defs` entry, so
+    // claiming by schemaPath alone would leave the biggest unions unreduced.
+    //
+    // Indexed by instancePath rather than scanned: an error is claimed by the
+    // DEEPEST occurrence enclosing it, which is found by walking that error's own
+    // path upwards — bounded by the path's depth instead of by the number of
+    // unions. The scan this replaced was O(errors × occurrences), and both grow
+    // with nesting depth on a recursive shape, on a path the editor runs per
+    // keystroke.
+    const byPath = new Map();
+    const isOccurrence = new Set();
+    for (const o of occurrences) {
+        isOccurrence.add(o.error);
+        // Several unions can occur at ONE value node (a union inside a union
+        // branch); the first is kept, and the rest nest under it below.
+        if (!byPath.has(o.instancePath))
+            byPath.set(o.instancePath, o);
+    }
+    /** The nearest occurrence at or above `path`, excluding `path` itself when
+     *  `strict` — which is how an occurrence finds its parent rather than itself. */
+    const enclosing = (path, strict) => {
+        let current = strict ? parentPath(path) : path;
+        while (current !== undefined) {
+            const hit = byPath.get(current);
+            if (hit)
+                return hit;
+            current = parentPath(current);
+        }
+        return undefined;
+    };
+    const owner = new Map();
+    for (const err of errors) {
+        if (isOccurrence.has(err))
+            continue;
+        const best = enclosing(err.instancePath || "", false);
+        if (best) {
+            best.owned.push(err);
+            owner.set(err, best);
+        }
+    }
+    // Nest occurrences the same way: an occurrence deeper in the value was reached
+    // through some branch of the nearest one enclosing it.
+    const roots = [];
+    for (const o of occurrences) {
+        const parent = o === byPath.get(o.instancePath)
+            ? enclosing(o.instancePath, true)
+            : byPath.get(o.instancePath);
+        if (parent && parent !== o)
+            parent.children.push(o);
+        else
+            roots.push(o);
+    }
+    const replaced = new Map();
+    for (const root of roots)
+        replaced.set(root.error, resolveOccurrence(root));
+    const out = [];
+    for (const err of errors) {
+        const replacement = replaced.get(err);
+        if (replacement) {
+            out.push(...replacement);
+            continue;
+        }
+        // Everything an occurrence owns is spoken for by whichever branch survived,
+        // and a nested occurrence is carried inside its parent's selection.
+        if (owner.has(err))
+            continue;
+        if (occurrences.some((o) => o.error === err))
+            continue;
+        out.push(err);
+    }
+    return out;
+}
+/** Groups one union's complaints into candidate readings of the value.
+ *
+ *  The branch INDEX is used wherever the error carries it. It does not when the
+ *  branch is a `$ref` — AJV reports under the target's schemaPath — so the
+ *  fallback groups by the VALUE NODE each complaint is about: everything said
+ *  about the union node itself is one candidate (those are the branches that
+ *  rejected the value's shape outright), and each child node complained about is
+ *  its own. That is the same question asked of the data instead of the schema,
+ *  and it is what the ordering below actually reads. */
+function groupCandidates(occurrence) {
+    const byIndex = new Map();
+    const byNode = new Map();
+    for (const err of occurrence.owned) {
+        const index = branchIndexUnder(occurrence.schemaPath, err.schemaPath);
+        const bucket = index === undefined
+            ? mapBucket(byNode, childSegment(err.instancePath || "", occurrence.instancePath))
+            : mapBucket(byIndex, index);
+        bucket.push(err);
+    }
+    return [...byIndex]
+        .map(([index, errs]) => ({ index, errors: errs, nested: false }))
+        .concat([...byNode].map(([, errs]) => ({ index: Number.MAX_SAFE_INTEGER, errors: errs, nested: false })))
+        .concat(occurrence.children.map((child) => ({
+        index: Number.POSITIVE_INFINITY,
+        errors: resolveOccurrence(child),
+        nested: true,
+    })));
+}
+function mapBucket(map, key) {
+    const existing = map.get(key);
+    if (existing)
+        return existing;
+    const created = [];
+    map.set(key, created);
+    return created;
+}
+/** The first value-path segment below `parent`, or "" for the node itself. */
+function childSegment(instancePath, parent) {
+    if (!isUnder(instancePath, parent))
+        return "";
+    const rest = instancePath.slice(parent.length + 1);
+    const slash = rest.indexOf("/");
+    return slash === -1 ? rest : rest.slice(0, slash);
+}
+function resolveOccurrence(occurrence) {
+    const candidates = groupCandidates(occurrence);
+    // `oneOf` matching SEVERAL branches emits the union error with no branch
+    // errors at all — nothing was rejected, so there is no branch to select.
+    if (candidates.length === 0)
+        return [occurrence.error];
+    const plausible = candidates.filter((c) => c.nested || isPlausible(c.errors, occurrence.instancePath));
+    if (plausible.length === 0) {
+        return [alternativesError(candidates, occurrence)];
+    }
+    // Deepest agreement first — a branch that matched further into the value is
+    // the one the author was writing — then the fewest complaints, then the
+    // declaration order, so the choice is stable.
+    plausible.sort((a, b) => {
+        const depth = maxDepth(b.errors) - maxDepth(a.errors);
+        if (depth !== 0)
+            return depth;
+        if (a.errors.length !== b.errors.length)
+            return a.errors.length - b.errors.length;
+        return a.index - b.index;
+    });
+    const winner = plausible[0];
+    return winner.nested ? winner.errors : reduceSchemaErrors(winner.errors);
+}
+function maxDepth(errors) {
+    let max = 0;
+    for (const e of errors)
+        max = Math.max(max, instanceDepth(e.instancePath));
+    return max;
+}
+/** One error anchored at the union node, listing what could have gone there.
+ *  The honest fallback: a confident wrong message is worse than the
+ *  concatenation this replaces, so when no branch is a plausible reading the
+ *  reader is told what the alternatives are rather than shown one branch's
+ *  complaints as if it were the intended one. */
+function alternativesError(candidates, occurrence) {
+    const seen = new Set();
+    const described = [];
+    for (const text of describeAlternatives(candidates.flatMap((c) => c.errors), occurrence.instancePath)) {
+        if (seen.has(text))
+            continue;
+        seen.add(text);
+        described.push(text);
+    }
+    return {
+        ...occurrence.error,
+        instancePath: occurrence.instancePath,
+        message: `matches no alternative — expected ${described.join(", or ")}`,
+    };
+}
+/* --------------------------------------------------------------- rendering */
+/** Converts an AJV error to a dotted path compatible with PositionIndex keys.
+ *  e.g. instancePath "/config/routes/0/handler" → "config.routes[0].handler"
+ *  For "required" keyword errors, appends the missing property to the parent path. */
+export function ajvErrorToPath(err) {
+    const instancePath = err.instancePath ?? "";
+    const parts = instancePath.split("/").filter((p) => p !== "");
+    let result = "";
+    for (const part of parts) {
+        if (/^\d+$/.test(part))
+            result += `[${part}]`;
+        else
+            result += result ? `.${part}` : part;
+    }
+    if (err.keyword === "required" && err.params?.missingProperty) {
+        const missing = err.params.missingProperty;
+        result += result ? `.${missing}` : missing;
+    }
+    return result;
+}
+/** Reduced, path-anchored issues — what a diagnostic list is built from. */
+export function schemaIssues(errors) {
+    return reduceSchemaErrors(errors).map((err) => ({
+        message: formatSingleError(err),
+        path: ajvErrorToPath(err),
+    }));
+}
+/** Reduced, rendered as one sentence — what a thrown runtime error carries. */
+export function formatAjvErrors(errors) {
+    const reduced = reduceSchemaErrors(errors);
+    if (reduced.length === 0)
+        return "Unknown schema error";
+    return reduced.map(formatSingleError).join("; ");
+}

package/dist/schema-projection.d.ts

@@ -47,6 +47,32 @@ export interface SchemaProjection {
     readonly nullable?: string;
     /** Entry field that wraps the mapped node in an array. */
     readonly array?: string;
+    /**
+     * How an entry whose keyed field holds a REFERENCE projects.
+     *
+     * The map is keyed on the field's VALUE, and a reference is not a key, so a
+     * `type:` holding one falls through to this path. It is declared as data by the
+     * backend, which is what keeps the analyzer from learning that an enum exists:
+     * `from` names the field of the target declaration to read, `keyword` the
+     * schema keyword its values become, and `base` / `baseFrom` where the node's
+     * own type comes from — a literal for an engine whose named type IS its own
+     * base, a field of the target for one that declares a storage class.
+     *
+     * A backend that declares none projects exactly as it did before.
+     */
+    readonly reference?: ProjectionReference;
+}
+/** The reference path of a projection — see {@link SchemaProjection.reference}. */
+export interface ProjectionReference {
+    /** Field of the TARGET declaration whose value the keyword takes. */
+    readonly from: string;
+    /** The JSON Schema keyword those values become (`enum`). */
+    readonly keyword: string;
+    /** The node the keyword is added to, written literally. */
+    readonly base?: Record<string, unknown>;
+    /** Field of the target declaration naming a value in the kind's own
+     *  `x-telo-schema-map`, whose mapped node is the base. */
+    readonly baseFrom?: string;
 }
 export type SchemaMap = Readonly<Record<string, Record<string, unknown>>>;
 /** The projection a kind declares, or undefined. Invalid shapes read as absent;
@@ -59,6 +85,18 @@ export declare function rawSchemaProjection(definition: unknown): unknown;
 /** True when the annotation was found inside `schema:` rather than on the
  *  document — the misplacement the strict half reports. */
 export declare function schemaProjectionIsMisplaced(definition: unknown): boolean;
+/**
+ * The schema node that CARRIES the value vocabulary — the node itself, or the
+ * branch of a union that declares the map.
+ *
+ * A slot unioning a closed value vocabulary with a reference keeps its map on the
+ * value branch, exactly as the ref-slot reader peels the same union for its
+ * constraint. Exported because the strict half checks the map against the same
+ * branch's `enum`, and two implementations of "which branch is the value one"
+ * would eventually disagree — silently, since the failure of missing one is a
+ * completeness check that quietly stops running.
+ */
+export declare function schemaMapBranch(node: unknown): Record<string, unknown> | undefined;
 export declare function readSchemaMap(node: unknown): SchemaMap | undefined;
 /** The consumer-side annotation: a JSON Pointer to this resource's ref slot
  *  whose target declares the projection. */
@@ -83,7 +121,16 @@ export declare function projectionKeyMap(kindSchema: unknown, projection: Schema
  * enough to double as a validator would move the domain's semantics into the
  * type layer.
  */
-export declare function projectEntries(manifest: unknown, projection: SchemaProjection, map: SchemaMap): Record<string, unknown> | undefined;
+export declare function projectEntries(manifest: unknown, projection: SchemaProjection, map: SchemaMap, 
+/** What a REFERENCE at the keyed field is resolved through, and where a
+ *  failure to resolve one is reported. A caller with no scope cannot resolve
+ *  one, so such an entry projects OPEN — present, untyped — rather than
+ *  vanishing from the row. */
+options?: {
+    readonly scope?: ProjectionScope;
+    readonly pointer?: string;
+    readonly failures?: ProjectionFailure[];
+}): Record<string, unknown> | undefined;
 /** A reference as the analyzer sees it: the internal `{kind, name, alias?}`
  *  shape `resolveRefSentinels` rewrites `!ref` to. */
 export interface ProjectionRef {
@@ -91,8 +138,17 @@ export interface ProjectionRef {
     readonly kind?: string;
     readonly alias?: string;
 }
-/** The `{kind, name, alias?}` reference a value holds, or undefined. Exported so
- *  a host whose slot may hold EITHER shape can fall back to this reading. */
+/**
+ * The `{kind, name, alias?}` reference a value holds, or undefined. Exported so
+ * a host whose slot may hold EITHER shape can fall back to this reading.
+ *
+ * The unresolved `!ref` SENTINEL is read too. `resolveRefSentinels` normally
+ * rewrites one before this pass, but not when the reference names nothing — and
+ * that is exactly when a projection failure is reported, so reading only the
+ * resolved shape made the diagnostic name the target `<unnamed>`, which is the
+ * one fact the author needed from it. A round-trip host (`compile` off) carries
+ * the sentinel for every reference, resolved or not.
+ */
 export declare function readProjectionRef(value: unknown): ProjectionRef | undefined;
 /** What a reference resolved to. `"ambiguous"` is distinct from `undefined`
  *  because the two need different advice: one says disambiguate, the other says
@@ -139,6 +195,16 @@ export interface ProjectionScope {
  * analysis has.
  */
 export declare function manifestListScope(manifests: readonly Record<string, any>[], resolveDefinition: (kind: string) => Record<string, any> | undefined): ProjectionScope;
+/**
+ * Why a slot could not be typed from a projection.
+ *
+ * Each reason is a DIFFERENT repair, which is why the three ways a target can
+ * carry no usable projection are kept apart rather than collapsed into
+ * `no-projection`: that one message ("declares no 'x-telo-schema-projection'")
+ * was printed for a kind that declares one whose key field carries no map, and
+ * for a declaration whose entry collection is simply absent — accusing the wrong
+ * author of the wrong omission in both.
+ */
 export type ProjectionFailure = {
     readonly reason: "no-ref";
     readonly pointer: string;
@@ -150,10 +216,36 @@ export type ProjectionFailure = {
     readonly reason: "ambiguous";
     readonly pointer: string;
     readonly name: string;
-} | {
+}
+/** The target's KIND declares no `x-telo-schema-projection` at all. */
+ | {
     readonly reason: "no-projection";
     readonly pointer: string;
     readonly kind: string;
+}
+/** It declares one, but the field it keys on carries no `x-telo-schema-map`. */
+ | {
+    readonly reason: "no-projection-map";
+    readonly pointer: string;
+    readonly kind: string;
+}
+/** Both are declared and the DECLARATION holds no entry collection to project
+ *  — an absent `columns:`, or a value that is not a collection. */
+ | {
+    readonly reason: "no-entries";
+    readonly pointer: string;
+    readonly kind: string;
+    readonly entries: string;
+}
+/** An ENTRY of the projected declaration references a shape that could not be
+ *  read. Reported rather than dropped: the entry would silently vanish from
+ *  the projected row, so a consumer naming it would be told the property does
+ *  not exist. */
+ | {
+    readonly reason: "entry-reference";
+    readonly pointer: string;
+    readonly entry: string;
+    readonly name: string;
 };
 export declare function describeProjectionFailure(failure: ProjectionFailure): string;
 /**
@@ -166,6 +258,16 @@ export declare function describeProjectionFailure(failure: ProjectionFailure): s
  * `failures`, because degrading SILENTLY is the failure this whole mechanism
  * exists to move earlier: the consumer's contract quietly reopens and a
  * misspelled field passes `telo check` exactly as it did before.
+ *
+ * **A node that projected NOTHING is returned by IDENTITY**, and that is a
+ * correctness property of the caller rather than a micro-optimization:
+ * `DefinitionRegistry` memoizes a compiled AJV validator per schema OBJECT,
+ * because every resource of a kind is checked against the same one at keystroke
+ * time. Rebuilding each node unconditionally — which this did — misses that memo
+ * for every resource in the analysis, so AJV recompiled the whole kind schema
+ * once per resource: on `apps/hub` that was 197 compiles instead of 54, and 723
+ * ms instead of 97. Returning the input where nothing changed restores it for
+ * every kind that declares no projection at all, which is nearly all of them.
  */
 export declare function resolveSchemaProjections(schema: unknown, manifest: Record<string, any> | undefined, scope: ProjectionScope, failures?: ProjectionFailure[]): unknown;
 //# sourceMappingURL=schema-projection.d.ts.map

package/dist/schema-projection.d.ts.map

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