@mmnto/totem 1.64.2 → 1.66.0

package/dist/spine/windtunnel-lock.d.ts

@@ -0,0 +1,440 @@
+import { z } from 'zod';
+export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
+    schema: z.ZodLiteral<"windtunnel.lock.v1">;
+    canonicalPath: z.ZodString;
+    gate: z.ZodString;
+    frozenAt: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: string | undefined;
+        commit?: string | undefined;
+    }, {
+        timestamp?: string | undefined;
+        commit?: string | undefined;
+    }>>;
+    phase: z.ZodEnum<["harness", "certifying"]>;
+    corpus: z.ZodObject<{
+        repo: z.ZodString;
+        selectionRule: z.ZodObject<{
+            state: z.ZodString;
+            predicate: z.ZodString;
+            window: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"all">;
+            }, "strip", z.ZodTypeAny, {
+                type: "all";
+            }, {
+                type: "all";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"bounded">;
+                n: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                type: "bounded";
+                n: number;
+            }, {
+                type: "bounded";
+                n: number;
+            }>]>;
+            asOfCommit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        }, {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        }>;
+        resolvedPrs: z.ZodArray<z.ZodObject<{
+            pr: z.ZodNumber;
+            mergeCommit: z.ZodString;
+            baseSha: z.ZodString;
+            headSha: z.ZodString;
+            diffSha: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }, {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        selectionRule: {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        };
+        resolvedPrs: {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }[];
+    }, {
+        repo: string;
+        selectionRule: {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        };
+        resolvedPrs: {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }[];
+    }>;
+    fpDefinition: z.ZodObject<{
+        rubricRef: z.ZodString;
+        groundTruthRef: z.ZodString;
+        adjudicator: z.ZodString;
+        precisionFloor: z.ZodLiteral<1>;
+    }, "strip", z.ZodTypeAny, {
+        rubricRef: string;
+        groundTruthRef: string;
+        adjudicator: string;
+        precisionFloor: 1;
+    }, {
+        rubricRef: string;
+        groundTruthRef: string;
+        adjudicator: string;
+        precisionFloor: 1;
+    }>;
+    controls: z.ZodObject<{
+        positiveRef: z.ZodString;
+        negativeRef: z.ZodString;
+        integrity: z.ZodObject<{
+            mechanism: z.ZodString;
+            fixtureSha: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            mechanism: string;
+            fixtureSha: string;
+        }, {
+            mechanism: string;
+            fixtureSha: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        positiveRef: string;
+        negativeRef: string;
+        integrity: {
+            mechanism: string;
+            fixtureSha: string;
+        };
+    }, {
+        positiveRef: string;
+        negativeRef: string;
+        integrity: {
+            mechanism: string;
+            fixtureSha: string;
+        };
+    }>;
+    cullRateThreshold: z.ZodNumber;
+    exposureDenominator: z.ZodObject<{
+        activeRulesEvaluated: z.ZodObject<{
+            floor: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            floor: number;
+        }, {
+            floor: number;
+        }>;
+        filesTouchedInWindow: z.ZodObject<{
+            floor: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            floor: number;
+        }, {
+            floor: number;
+        }>;
+        positiveControlsExercised: z.ZodObject<{
+            floor: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            floor: number;
+        }, {
+            floor: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        activeRulesEvaluated: {
+            floor: number;
+        };
+        filesTouchedInWindow: {
+            floor: number;
+        };
+        positiveControlsExercised: {
+            floor: number;
+        };
+    }, {
+        activeRulesEvaluated: {
+            floor: number;
+        };
+        filesTouchedInWindow: {
+            floor: number;
+        };
+        positiveControlsExercised: {
+            floor: number;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schema: "windtunnel.lock.v1";
+    corpus: {
+        repo: string;
+        selectionRule: {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        };
+        resolvedPrs: {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }[];
+    };
+    canonicalPath: string;
+    gate: string;
+    phase: "harness" | "certifying";
+    fpDefinition: {
+        rubricRef: string;
+        groundTruthRef: string;
+        adjudicator: string;
+        precisionFloor: 1;
+    };
+    controls: {
+        positiveRef: string;
+        negativeRef: string;
+        integrity: {
+            mechanism: string;
+            fixtureSha: string;
+        };
+    };
+    cullRateThreshold: number;
+    exposureDenominator: {
+        activeRulesEvaluated: {
+            floor: number;
+        };
+        filesTouchedInWindow: {
+            floor: number;
+        };
+        positiveControlsExercised: {
+            floor: number;
+        };
+    };
+    frozenAt?: {
+        timestamp?: string | undefined;
+        commit?: string | undefined;
+    } | undefined;
+}, {
+    schema: "windtunnel.lock.v1";
+    corpus: {
+        repo: string;
+        selectionRule: {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        };
+        resolvedPrs: {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }[];
+    };
+    canonicalPath: string;
+    gate: string;
+    phase: "harness" | "certifying";
+    fpDefinition: {
+        rubricRef: string;
+        groundTruthRef: string;
+        adjudicator: string;
+        precisionFloor: 1;
+    };
+    controls: {
+        positiveRef: string;
+        negativeRef: string;
+        integrity: {
+            mechanism: string;
+            fixtureSha: string;
+        };
+    };
+    cullRateThreshold: number;
+    exposureDenominator: {
+        activeRulesEvaluated: {
+            floor: number;
+        };
+        filesTouchedInWindow: {
+            floor: number;
+        };
+        positiveControlsExercised: {
+            floor: number;
+        };
+    };
+    frozenAt?: {
+        timestamp?: string | undefined;
+        commit?: string | undefined;
+    } | undefined;
+}>, {
+    schema: "windtunnel.lock.v1";
+    corpus: {
+        repo: string;
+        selectionRule: {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        };
+        resolvedPrs: {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }[];
+    };
+    canonicalPath: string;
+    gate: string;
+    phase: "harness" | "certifying";
+    fpDefinition: {
+        rubricRef: string;
+        groundTruthRef: string;
+        adjudicator: string;
+        precisionFloor: 1;
+    };
+    controls: {
+        positiveRef: string;
+        negativeRef: string;
+        integrity: {
+            mechanism: string;
+            fixtureSha: string;
+        };
+    };
+    cullRateThreshold: number;
+    exposureDenominator: {
+        activeRulesEvaluated: {
+            floor: number;
+        };
+        filesTouchedInWindow: {
+            floor: number;
+        };
+        positiveControlsExercised: {
+            floor: number;
+        };
+    };
+    frozenAt?: {
+        timestamp?: string | undefined;
+        commit?: string | undefined;
+    } | undefined;
+}, {
+    schema: "windtunnel.lock.v1";
+    corpus: {
+        repo: string;
+        selectionRule: {
+            state: string;
+            predicate: string;
+            window: {
+                type: "all";
+            } | {
+                type: "bounded";
+                n: number;
+            };
+            asOfCommit: string;
+        };
+        resolvedPrs: {
+            headSha: string;
+            pr: number;
+            mergeCommit: string;
+            baseSha: string;
+            diffSha?: string | undefined;
+        }[];
+    };
+    canonicalPath: string;
+    gate: string;
+    phase: "harness" | "certifying";
+    fpDefinition: {
+        rubricRef: string;
+        groundTruthRef: string;
+        adjudicator: string;
+        precisionFloor: 1;
+    };
+    controls: {
+        positiveRef: string;
+        negativeRef: string;
+        integrity: {
+            mechanism: string;
+            fixtureSha: string;
+        };
+    };
+    cullRateThreshold: number;
+    exposureDenominator: {
+        activeRulesEvaluated: {
+            floor: number;
+        };
+        filesTouchedInWindow: {
+            floor: number;
+        };
+        positiveControlsExercised: {
+            floor: number;
+        };
+    };
+    frozenAt?: {
+        timestamp?: string | undefined;
+        commit?: string | undefined;
+    } | undefined;
+}>;
+export type WindtunnelLock = z.infer<typeof WindtunnelLockSchema>;
+/**
+ * Compute a content-based per-firing label id (A2).
+ * Keyed on hash(ruleId + pr + filePath + normalizedMatchedLineText) to survive
+ * line-drift without raw line-number anchoring.
+ */
+export declare function firingLabelId(ruleId: string, pr: number, filePath: string, normalizedMatchedLineText: string): string;
+//# sourceMappingURL=windtunnel-lock.d.ts.map

package/dist/spine/windtunnel-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windtunnel-lock.d.ts","sourceRoot":"","sources":["../../src/spine/windtunnel-lock.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2F7B,CAAC;AAEL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAIlE;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,yBAAyB,EAAE,MAAM,GAChC,MAAM,CAMR"}

package/dist/spine/windtunnel-lock.js

@@ -0,0 +1,115 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+// ─── Named constants ─────────────────────────────────
+const COMMIT_SHA_REGEX = /^[0-9a-f]{40}$/;
+const MIN_ACTIVE_RULES_FLOOR = 2;
+// ─── Sub-schemas ─────────────────────────────────────
+const ResolvedPrSchema = z.object({
+    pr: z.number().int().positive(),
+    mergeCommit: z.string().regex(COMMIT_SHA_REGEX, 'mergeCommit must be a 40-hex SHA'),
+    baseSha: z.string().regex(COMMIT_SHA_REGEX, 'baseSha must be a 40-hex SHA'),
+    headSha: z.string().regex(COMMIT_SHA_REGEX, 'headSha must be a 40-hex SHA'),
+    diffSha: z.string().regex(COMMIT_SHA_REGEX, 'diffSha must be a 40-hex SHA').optional(),
+});
+// ─── Main schema ─────────────────────────────────────
+export const WindtunnelLockSchema = z
+    .object({
+    schema: z.literal('windtunnel.lock.v1'),
+    canonicalPath: z.string(),
+    gate: z.string(),
+    // frozenAt.commit is NOT trusted as a freeze proof (C3 — proof is git-derived at run time).
+    frozenAt: z
+        .object({
+        timestamp: z.string().optional(),
+        commit: z.string().optional(),
+    })
+        .optional(),
+    phase: z.enum(['harness', 'certifying']),
+    corpus: z.object({
+        repo: z.string(),
+        selectionRule: z.object({
+            state: z.string(),
+            predicate: z.string(),
+            window: z.discriminatedUnion('type', [
+                z.object({ type: z.literal('all') }),
+                z.object({ type: z.literal('bounded'), n: z.number().int().positive() }),
+            ]),
+            asOfCommit: z.string().regex(COMMIT_SHA_REGEX, 'asOfCommit must be a 40-hex SHA'),
+        }),
+        resolvedPrs: z.array(ResolvedPrSchema).min(1, 'resolvedPrs must be non-empty'),
+    }),
+    fpDefinition: z.object({
+        rubricRef: z.string(),
+        groundTruthRef: z.string(),
+        adjudicator: z.string(),
+        precisionFloor: z.literal(1.0),
+    }),
+    controls: z.object({
+        positiveRef: z.string(),
+        negativeRef: z.string(),
+        integrity: z.object({
+            mechanism: z.string(),
+            // fixtureSha is a git hash-object digest (40-hex) that feeds the
+            // hard-error integrity gate — validate its format here so a malformed
+            // value fails at parse, not cryptically at run (greptile P2).
+            fixtureSha: z.string().regex(COMMIT_SHA_REGEX, 'fixtureSha must be a 40-hex SHA'),
+        }),
+    }),
+    cullRateThreshold: z
+        .number()
+        .min(0, 'cullRateThreshold must be >= 0')
+        .lt(1, 'cullRateThreshold must be < 1'),
+    exposureDenominator: z.object({
+        activeRulesEvaluated: z.object({
+            floor: z
+                .number()
+                .int()
+                .min(MIN_ACTIVE_RULES_FLOOR, `activeRulesEvaluated.floor must be >= ${MIN_ACTIVE_RULES_FLOOR}`),
+        }),
+        filesTouchedInWindow: z.object({
+            floor: z.number().int().nonnegative(),
+        }),
+        positiveControlsExercised: z.object({
+            floor: z.number().int().nonnegative(),
+        }),
+    }),
+})
+    .superRefine((data, ctx) => {
+    const prs = data.corpus.resolvedPrs;
+    const prNums = prs.map((p) => p.pr);
+    // C4: unique pr numbers
+    const uniquePrs = new Set(prNums);
+    if (uniquePrs.size !== prNums.length) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'resolvedPrs must have unique pr numbers',
+            path: ['corpus', 'resolvedPrs'],
+        });
+    }
+    // C4: sorted ascending by pr number
+    const sortedPrNums = [...prNums].sort((a, b) => a - b);
+    for (let i = 0; i < prNums.length; i++) {
+        if (prNums[i] !== sortedPrNums[i]) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'resolvedPrs must be sorted ascending by pr number',
+                path: ['corpus', 'resolvedPrs'],
+            });
+            break;
+        }
+    }
+});
+// ─── Utilities ───────────────────────────────────────
+/**
+ * Compute a content-based per-firing label id (A2).
+ * Keyed on hash(ruleId + pr + filePath + normalizedMatchedLineText) to survive
+ * line-drift without raw line-number anchoring.
+ */
+export function firingLabelId(ruleId, pr, filePath, normalizedMatchedLineText) {
+    // A3: normalize path to forward-slash (Windows cross-platform)
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    return createHash('sha256')
+        .update(`${ruleId}\x00${pr}\x00${normalizedPath}\x00${normalizedMatchedLineText}`)
+        .digest('hex');
+}
+//# sourceMappingURL=windtunnel-lock.js.map

package/dist/spine/windtunnel-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"windtunnel-lock.js","sourceRoot":"","sources":["../../src/spine/windtunnel-lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wDAAwD;AAExD,MAAM,gBAAgB,GAAG,gBAAgB,CAAC;AAC1C,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAEjC,wDAAwD;AAExD,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IAC/B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,kCAAkC,CAAC;IACnF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;IAC3E,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;IAC3E,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,8BAA8B,CAAC,CAAC,QAAQ,EAAE;CACvF,CAAC,CAAC;AAEH,wDAAwD;AAExD,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IACvC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,4FAA4F;IAC5F,QAAQ,EAAE,CAAC;SACR,MAAM,CAAC;QACN,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAChC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC9B,CAAC;SACD,QAAQ,EAAE;IACb,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IACxC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,aAAa,EAAE,CAAC,CAAC,MAAM,CAAC;YACtB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;YACjB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;YACrB,MAAM,EAAE,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;gBACnC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC;aACzE,CAAC;YACF,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,iCAAiC,CAAC;SAClF,CAAC;QACF,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,+BAA+B,CAAC;KAC/E,CAAC;IACF,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC;QACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;QACrB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;QAC1B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;QACvB,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;KAC/B,CAAC;IACF,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC;QACjB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;QACvB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;QACvB,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC;YAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;YACrB,iEAAiE;YACjE,sEAAsE;YACtE,8DAA8D;YAC9D,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,iCAAiC,CAAC;SAClF,CAAC;KACH,CAAC;IACF,iBAAiB,EAAE,CAAC;SACjB,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,EAAE,gCAAgC,CAAC;SACxC,EAAE,CAAC,CAAC,EAAE,+BAA+B,CAAC;IACzC,mBAAmB,EAAE,CAAC,CAAC,MAAM,CAAC;QAC5B,oBAAoB,EAAE,CAAC,CAAC,MAAM,CAAC;YAC7B,KAAK,EAAE,CAAC;iBACL,MAAM,EAAE;iBACR,GAAG,EAAE;iBACL,GAAG,CACF,sBAAsB,EACtB,yCAAyC,sBAAsB,EAAE,CAClE;SACJ,CAAC;QACF,oBAAoB,EAAE,CAAC,CAAC,MAAM,CAAC;YAC7B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;SACtC,CAAC;QACF,yBAAyB,EAAE,CAAC,CAAC,MAAM,CAAC;YAClC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;SACtC,CAAC;KACH,CAAC;CACH,CAAC;KACD,WAAW,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACzB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;IACpC,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAEpC,wBAAwB;IACxB,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,SAAS,CAAC,IAAI,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;QACrC,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;YAC3B,OAAO,EAAE,yCAAyC;YAClD,IAAI,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC;SAChC,CAAC,CAAC;IACL,CAAC;IAED,oCAAoC;IACpC,MAAM,YAAY,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;YAClC,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;gBAC3B,OAAO,EAAE,mDAAmD;gBAC5D,IAAI,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC;aAChC,CAAC,CAAC;YACH,MAAM;QACR,CAAC;IACH,CAAC;AACH,CAAC,CAAC,CAAC;AAIL,wDAAwD;AAExD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAc,EACd,EAAU,EACV,QAAgB,EAChB,yBAAiC;IAEjC,+DAA+D;IAC/D,MAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACpD,OAAO,UAAU,CAAC,QAAQ,CAAC;SACxB,MAAM,CAAC,GAAG,MAAM,OAAO,EAAE,OAAO,cAAc,OAAO,yBAAyB,EAAE,CAAC;SACjF,MAAM,CAAC,KAAK,CAAC,CAAC;AACnB,CAAC"}

package/dist/spine/windtunnel-lock.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=windtunnel-lock.test.d.ts.map

package/dist/spine/windtunnel-lock.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windtunnel-lock.test.d.ts","sourceRoot":"","sources":["../../src/spine/windtunnel-lock.test.ts"],"names":[],"mappings":""}