@gate-forge/core 0.10.4 → 0.11.0

package/dist/schemas/business-rules.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Owner-declared BUSINESS RULES (plan 2026-10-05 §4 D1/D2) and the test
+ * type table that decides what proof each rule's declared test type
+ * requires.
+ *
+ * Two deliberate separations:
+ * - A RULE is a DECLARATION, never an obligation. It has no detector
+ *   resource, no contract namespace and no verifier; it is graded by a
+ *   pure evaluator over the run's SEALED facts (see `policy/business-rules.ts`).
+ *   Nothing here mints an obligation id.
+ * - The TYPE TABLE is DATA, one row per supported `test:` value. Proof
+ *   strength follows the type, and a weaker kind never satisfies a
+ *   stronger one. Adding a type later is one row plus its honest proof
+ *   level, never a change to the evaluator.
+ *
+ * The claim id per case is `business-rule:<ruleId>/<caseId>`, which
+ * satisfies the existing `<resourceId>:<contract>` shape so the sidecar
+ * schema is unchanged — the sidecar stores it under the SAME `claims`
+ * list it already uses for obligations.
+ *
+ * YAML parsing stays in the CLI (the existing core/CLI split); this
+ * module speaks validated plain data only.
+ */
+import { z } from 'zod';
+/** The claim namespace every business-rule case id lives in. */
+export declare const BUSINESS_RULE_NAMESPACE = "business-rule";
+/**
+ * The claim id one case is mapped by: `business-rule:<ruleId>/<caseId>`.
+ * Deterministic and stable, so a sidecar entry survives a re-order of
+ * `cases:` and the evaluator can join bindings to cases by string.
+ */
+export declare function businessRuleClaimId(ruleId: string, caseId: string): string;
+/** Whether one claim id belongs to the business-rule namespace. */
+export declare function isBusinessRuleClaimId(claimId: string): boolean;
+/**
+ * The `<ruleId>/<caseId>` pair a business-rule claim id carries, or null
+ * when the id is not a business-rule claim or carries no case part.
+ */
+export declare function parseBusinessRuleClaimId(claimId: string): {
+    ruleId: string;
+    caseId: string;
+} | null;
+/** The test types this release ships. More are one table row each. */
+export declare const BUSINESS_RULE_TEST_TYPES: readonly ["e2e", "pytest"];
+/** Union of the supported rule test types. */
+export type BusinessRuleTestType = (typeof BUSINESS_RULE_TEST_TYPES)[number];
+/** One declared observable consequence of a rule (typically both sides). */
+export declare const BusinessRuleCaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    describe: z.ZodString;
+}, z.core.$strict>;
+/** Inferred business-rule-case shape. */
+export type BusinessRuleCase = z.infer<typeof BusinessRuleCaseSchema>;
+/**
+ * Ranking-only hints for `tests suggest`. They NEVER grade: a hint can
+ * promote a candidate, never prove anything, and a rule with no hints
+ * behaves exactly like a rule with them.
+ */
+export declare const BusinessRuleHintsSchema: z.ZodObject<{
+    routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/** Inferred business-rule-hints shape. */
+export type BusinessRuleHints = z.infer<typeof BusinessRuleHintsSchema>;
+/**
+ * One owner-declared business rule. Every field is a DECLARATION: it
+ * changes the trusted policy digest (the rule lives in the owner-answers
+ * document) and therefore can never be self-approved by an agent.
+ */
+export declare const BusinessRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    test: z.ZodDefault<z.ZodEnum<{
+        e2e: "e2e";
+        pytest: "pytest";
+    }>>;
+    enforcement: z.ZodDefault<z.ZodEnum<{
+        block: "block";
+        advisory: "advisory";
+    }>>;
+    advisoryReason: z.ZodOptional<z.ZodString>;
+    cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        describe: z.ZodString;
+    }, z.core.$strict>>>;
+    hints: z.ZodOptional<z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Inferred business-rule shape. */
+export type BusinessRule = z.infer<typeof BusinessRuleSchema>;
+/**
+ * The `rules:` section. Duplicate rule ids are an ambiguity, not a
+ * last-one-wins: two rules with one id cannot be graded deterministically.
+ */
+export declare const BusinessRulesSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    test: z.ZodDefault<z.ZodEnum<{
+        e2e: "e2e";
+        pytest: "pytest";
+    }>>;
+    enforcement: z.ZodDefault<z.ZodEnum<{
+        block: "block";
+        advisory: "advisory";
+    }>>;
+    advisoryReason: z.ZodOptional<z.ZodString>;
+    cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        describe: z.ZodString;
+    }, z.core.$strict>>>;
+    hints: z.ZodOptional<z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+/** Inferred business-rules section shape. */
+export type BusinessRules = z.infer<typeof BusinessRulesSchema>;
+/** The case id a rule without `cases:` uses. */
+export declare const IMPLICIT_CASE_ID = "default";
+/**
+ * The rule's cases with the implicit `default` case materialized. Pure:
+ * a rule that declares cases returns exactly those, in order.
+ */
+export declare function casesOf(rule: BusinessRule): BusinessRuleCase[];
+/**
+ * The owners-answers document's RULE section: `rules:` is optional and
+ * an ABSENT section means the feature is off — byte-identical findings,
+ * report and digests to a release without it (plan invariant 1).
+ */
+export declare const BusinessRulePolicySchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        describe: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        test: z.ZodDefault<z.ZodEnum<{
+            e2e: "e2e";
+            pytest: "pytest";
+        }>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            block: "block";
+            advisory: "advisory";
+        }>>;
+        advisoryReason: z.ZodOptional<z.ZodString>;
+        cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            describe: z.ZodString;
+        }, z.core.$strict>>>;
+        hints: z.ZodOptional<z.ZodObject<{
+            routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Inferred business-rule-policy section shape. */
+export type BusinessRulePolicy = z.infer<typeof BusinessRulePolicySchema>;
+/**
+ * One row of the TYPE TABLE (plan D2). `acceptedKinds` is closed-world:
+ * a binding of any other kind is `wrong-type`, never quietly accepted,
+ * and a no-weaker-kind rule means a row never inherits another row's
+ * kinds.
+ */
+export interface BusinessRuleTypeRow {
+    /** The `test:` value this row answers to. */
+    readonly id: BusinessRuleTestType;
+    /** Human label used in every message and starter test. */
+    readonly label: string;
+    /** The runner every accepted test must execute under. */
+    readonly runner: string;
+    /** Test kinds that may satisfy this type (closed-world). */
+    readonly acceptedKinds: readonly string[];
+    /** Proof channel per accepted kind, named in the report. */
+    readonly kindChannels: Readonly<Record<string, string>>;
+    /** The channel named when the row's tests all carry the same one. */
+    readonly defaultChannel: string;
+    /**
+     * True when the proof additionally requires the run's WITNESSED suite
+     * for the type's runner (`diagnostics.suites[].witnessed`). A pytest
+     * rule without one stays `unproven` — no weaker labelled proof.
+     */
+    readonly requiresWitnessedSuite: boolean;
+    /** What `next` prints as the starter test for this type. */
+    readonly starter: 'playwright' | 'pytest';
+}
+/**
+ * THE type table: one row per supported `test:` value. Proof strength
+ * follows the type, and a weaker kind is never accepted by a stronger
+ * row — `e2e` is never satisfied by `api-e2e`, `server-e2e`, `unit`, a
+ * mocked spec, or a test that did not run.
+ */
+export declare const BUSINESS_RULE_TYPE_TABLE: Readonly<Record<BusinessRuleTestType, BusinessRuleTypeRow>>;
+/** The type table as a deterministic list (sorted by type id). */
+export declare function businessRuleTypeRows(): BusinessRuleTypeRow[];
+/**
+ * The per-case status the evaluator reports. `satisfied` carries the
+ * proof channel in its label (`satisfied (observe)`), because "satisfied"
+ * read as "the rule holds" is exactly the overclaim invariant 6 forbids.
+ */
+export declare const BUSINESS_RULE_CASE_STATUSES: readonly ["unmapped", "wrong-type", "unproven", "failing", "satisfied"];
+/** Union of the per-case statuses. */
+export type BusinessRuleCaseStatus = (typeof BUSINESS_RULE_CASE_STATUSES)[number];
+/**
+ * The `rules:` key as it appears in the owner-answers document, named
+ * once so the loader, the migrator and the init template cannot drift.
+ */
+export declare const BUSINESS_RULES_KEY = "rules";
+/** The `schemaVersion` every engine document carries. */
+export declare const BusinessRuleSchemaVersionField: z.ZodLiteral<1>;
+//# sourceMappingURL=business-rules.d.ts.map

package/dist/schemas/business-rules.d.ts.map

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

package/dist/schemas/business-rules.js

@@ -0,0 +1,227 @@
+/**
+ * Owner-declared BUSINESS RULES (plan 2026-10-05 §4 D1/D2) and the test
+ * type table that decides what proof each rule's declared test type
+ * requires.
+ *
+ * Two deliberate separations:
+ * - A RULE is a DECLARATION, never an obligation. It has no detector
+ *   resource, no contract namespace and no verifier; it is graded by a
+ *   pure evaluator over the run's SEALED facts (see `policy/business-rules.ts`).
+ *   Nothing here mints an obligation id.
+ * - The TYPE TABLE is DATA, one row per supported `test:` value. Proof
+ *   strength follows the type, and a weaker kind never satisfies a
+ *   stronger one. Adding a type later is one row plus its honest proof
+ *   level, never a change to the evaluator.
+ *
+ * The claim id per case is `business-rule:<ruleId>/<caseId>`, which
+ * satisfies the existing `<resourceId>:<contract>` shape so the sidecar
+ * schema is unchanged — the sidecar stores it under the SAME `claims`
+ * list it already uses for obligations.
+ *
+ * YAML parsing stays in the CLI (the existing core/CLI split); this
+ * module speaks validated plain data only.
+ */
+import { z } from 'zod';
+import { SchemaVersionField } from './common.js';
+/** The claim namespace every business-rule case id lives in. */
+export const BUSINESS_RULE_NAMESPACE = 'business-rule';
+/**
+ * The claim id one case is mapped by: `business-rule:<ruleId>/<caseId>`.
+ * Deterministic and stable, so a sidecar entry survives a re-order of
+ * `cases:` and the evaluator can join bindings to cases by string.
+ */
+export function businessRuleClaimId(ruleId, caseId) {
+    return `${BUSINESS_RULE_NAMESPACE}:${ruleId}/${caseId}`;
+}
+/** Whether one claim id belongs to the business-rule namespace. */
+export function isBusinessRuleClaimId(claimId) {
+    return claimId.startsWith(`${BUSINESS_RULE_NAMESPACE}:`);
+}
+/**
+ * The `<ruleId>/<caseId>` pair a business-rule claim id carries, or null
+ * when the id is not a business-rule claim or carries no case part.
+ */
+export function parseBusinessRuleClaimId(claimId) {
+    if (!isBusinessRuleClaimId(claimId))
+        return null;
+    const rest = claimId.slice(`${BUSINESS_RULE_NAMESPACE}:`.length);
+    const slash = rest.lastIndexOf('/');
+    if (slash <= 0 || slash === rest.length - 1)
+        return null;
+    return { ruleId: rest.slice(0, slash), caseId: rest.slice(slash + 1) };
+}
+/** Rule ids are stable, filesystem- and URL-safe slugs. */
+const RULE_ID = /^[a-z0-9][a-z0-9._-]*$/;
+/** Case ids follow the same rule inside their rule. */
+const CASE_ID = /^[a-z0-9][a-z0-9._-]*$/;
+/** The test types this release ships. More are one table row each. */
+export const BUSINESS_RULE_TEST_TYPES = ['e2e', 'pytest'];
+/** One declared observable consequence of a rule (typically both sides). */
+export const BusinessRuleCaseSchema = z
+    .object({
+    /** Case id, unique inside its rule; joined as `<ruleId>/<caseId>`. */
+    id: z.string().regex(CASE_ID, 'case id must match [a-z0-9][a-z0-9._-]*'),
+    /** What the case says must be observed; required (a case with no words cannot be reviewed). */
+    describe: z.string().trim().min(1),
+})
+    .strict();
+/**
+ * Ranking-only hints for `tests suggest`. They NEVER grade: a hint can
+ * promote a candidate, never prove anything, and a rule with no hints
+ * behaves exactly like a rule with them.
+ */
+export const BusinessRuleHintsSchema = z
+    .object({
+    /** URL path globs the proving test is expected to send. */
+    routes: z.array(z.string().min(1)).optional(),
+    /** Repo-relative file globs the proving test is expected to live in. */
+    globs: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+/**
+ * One owner-declared business rule. Every field is a DECLARATION: it
+ * changes the trusted policy digest (the rule lives in the owner-answers
+ * document) and therefore can never be self-approved by an agent.
+ */
+export const BusinessRuleSchema = z
+    .object({
+    /** Stable rule id; unique in the document. */
+    id: z.string().regex(RULE_ID, 'rule id must match [a-z0-9][a-z0-9._-]*'),
+    /** The rule in the owner's own words (required: a rule with no title cannot be reviewed). */
+    title: z.string().trim().min(1),
+    /** Optional longer prose; the title stays the one-line statement. */
+    describe: z.string().trim().min(1).optional(),
+    /** Optional resource name; validated against the run's inventory (never proof). */
+    subject: z.string().trim().min(1).optional(),
+    /** Which kind of test must prove it. `e2e` is the default. */
+    test: z.enum(BUSINESS_RULE_TEST_TYPES).default('e2e'),
+    /** `block` (default) or `advisory`; advisory findings never reach the exit code. */
+    enforcement: z.enum(['block', 'advisory']).default('block'),
+    /** REQUIRED iff `enforcement: advisory` — an advisory with no reason hides itself. */
+    advisoryReason: z.string().trim().min(1).optional(),
+    /** Observable cases; absent means the single implicit case `default`. */
+    cases: z.array(BusinessRuleCaseSchema).min(1).optional(),
+    /** Ranking-only hints for `tests suggest`. */
+    hints: BusinessRuleHintsSchema.optional(),
+})
+    .strict()
+    .superRefine((rule, ctx) => {
+    if (rule.enforcement === 'advisory' && rule.advisoryReason === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['advisoryReason'],
+            message: "rule '" + rule.id + "' is advisory but declares no advisoryReason: an advisory rule must say why it does not block",
+        });
+    }
+    if (rule.enforcement === 'block' && rule.advisoryReason !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['advisoryReason'],
+            message: "rule '" + rule.id + "' blocks but declares advisoryReason: the reason belongs on an advisory rule only",
+        });
+    }
+    const seen = new Set();
+    for (let index = 0; index < (rule.cases ?? []).length; index += 1) {
+        const id = rule.cases?.[index]?.id;
+        if (id === undefined)
+            continue;
+        if (seen.has(id)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['cases', index, 'id'],
+                message: `duplicate case id '${id}' in rule '${rule.id}'`,
+            });
+        }
+        seen.add(id);
+    }
+});
+/**
+ * The `rules:` section. Duplicate rule ids are an ambiguity, not a
+ * last-one-wins: two rules with one id cannot be graded deterministically.
+ */
+export const BusinessRulesSchema = z
+    .array(BusinessRuleSchema)
+    .superRefine((rules, ctx) => {
+    const seen = new Set();
+    for (let index = 0; index < rules.length; index += 1) {
+        const id = rules[index]?.id;
+        if (id === undefined)
+            continue;
+        if (seen.has(id)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: [index, 'id'],
+                message: `duplicate business rule id '${id}' — every rule must be separately addressable`,
+            });
+        }
+        seen.add(id);
+    }
+});
+/** The case id a rule without `cases:` uses. */
+export const IMPLICIT_CASE_ID = 'default';
+/**
+ * The rule's cases with the implicit `default` case materialized. Pure:
+ * a rule that declares cases returns exactly those, in order.
+ */
+export function casesOf(rule) {
+    if (rule.cases !== undefined && rule.cases.length > 0)
+        return [...rule.cases];
+    return [{ id: IMPLICIT_CASE_ID, describe: rule.title }];
+}
+/**
+ * The owners-answers document's RULE section: `rules:` is optional and
+ * an ABSENT section means the feature is off — byte-identical findings,
+ * report and digests to a release without it (plan invariant 1).
+ */
+export const BusinessRulePolicySchema = z
+    .object({
+    /** Owner-declared business rules. */
+    rules: z.array(BusinessRuleSchema),
+})
+    .strict();
+/**
+ * THE type table: one row per supported `test:` value. Proof strength
+ * follows the type, and a weaker kind is never accepted by a stronger
+ * row — `e2e` is never satisfied by `api-e2e`, `server-e2e`, `unit`, a
+ * mocked spec, or a test that did not run.
+ */
+export const BUSINESS_RULE_TYPE_TABLE = Object.freeze({
+    e2e: Object.freeze({
+        id: 'e2e',
+        label: 'e2e',
+        runner: 'playwright',
+        acceptedKinds: Object.freeze(['browser-e2e', 'observed-e2e']),
+        kindChannels: Object.freeze({ 'browser-e2e': 'engine', 'observed-e2e': 'observe' }),
+        defaultChannel: 'observe',
+        requiresWitnessedSuite: false,
+        starter: 'playwright',
+    }),
+    pytest: Object.freeze({
+        id: 'pytest',
+        label: 'pytest',
+        runner: 'pytest',
+        acceptedKinds: Object.freeze(['unit', 'integration', 'server-e2e']),
+        kindChannels: Object.freeze({ unit: 'execution', integration: 'execution', 'server-e2e': 'execution' }),
+        defaultChannel: 'execution',
+        requiresWitnessedSuite: true,
+        starter: 'pytest',
+    }),
+});
+/** The type table as a deterministic list (sorted by type id). */
+export function businessRuleTypeRows() {
+    return [...BUSINESS_RULE_TEST_TYPES].sort().map((id) => BUSINESS_RULE_TYPE_TABLE[id]);
+}
+/**
+ * The per-case status the evaluator reports. `satisfied` carries the
+ * proof channel in its label (`satisfied (observe)`), because "satisfied"
+ * read as "the rule holds" is exactly the overclaim invariant 6 forbids.
+ */
+export const BUSINESS_RULE_CASE_STATUSES = ['unmapped', 'wrong-type', 'unproven', 'failing', 'satisfied'];
+/**
+ * The `rules:` key as it appears in the owner-answers document, named
+ * once so the loader, the migrator and the init template cannot drift.
+ */
+export const BUSINESS_RULES_KEY = 'rules';
+/** The `schemaVersion` every engine document carries. */
+export const BusinessRuleSchemaVersionField = SchemaVersionField;
+//# sourceMappingURL=business-rules.js.map

package/dist/schemas/business-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"business-rules.js","sourceRoot":"","sources":["../../src/schemas/business-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,gEAAgE;AAChE,MAAM,CAAC,MAAM,uBAAuB,GAAG,eAAe,CAAC;AAEvD;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAc,EAAE,MAAc;IAChE,OAAO,GAAG,uBAAuB,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAC1D,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,qBAAqB,CAAC,OAAe;IACnD,OAAO,OAAO,CAAC,UAAU,CAAC,GAAG,uBAAuB,GAAG,CAAC,CAAC;AAC3D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAe;IACtD,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IACjD,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,uBAAuB,GAAG,CAAC,MAAM,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACzD,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;AACzE,CAAC;AAED,2DAA2D;AAC3D,MAAM,OAAO,GAAG,wBAAwB,CAAC;AAEzC,uDAAuD;AACvD,MAAM,OAAO,GAAG,wBAAwB,CAAC;AAEzC,sEAAsE;AACtE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAU,CAAC;AAKnE,4EAA4E;AAC5E,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,MAAM,CAAC;IACN,sEAAsE;IACtE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,yCAAyC,CAAC;IACxE,+FAA+F;IAC/F,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACnC,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC;KACrC,MAAM,CAAC;IACN,2DAA2D;IAC3D,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC7C,wEAAwE;IACxE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC7C,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KAChC,MAAM,CAAC;IACN,8CAA8C;IAC9C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,yCAAyC,CAAC;IACxE,6FAA6F;IAC7F,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC7C,mFAAmF;IACnF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC5C,8DAA8D;IAC9D,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IACrD,oFAAoF;IACpF,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IAC3D,sFAAsF;IACtF,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACnD,yEAAyE;IACzE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACxD,8CAA8C;IAC9C,KAAK,EAAE,uBAAuB,CAAC,QAAQ,EAAE;CAC1C,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACzB,IAAI,IAAI,CAAC,WAAW,KAAK,UAAU,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACzE,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,gBAAgB,CAAC;YACxB,OAAO,EACL,QAAQ,GAAG,IAAI,CAAC,EAAE,GAAG,+FAA+F;SACvH,CAAC,CAAC;IACL,CAAC;IACD,IAAI,IAAI,CAAC,WAAW,KAAK,OAAO,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACtE,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,gBAAgB,CAAC;YACxB,OAAO,EACL,QAAQ,GAAG,IAAI,CAAC,EAAE,GAAG,mFAAmF;SAC3G,CAAC,CAAC;IACL,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAClE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;QACnC,IAAI,EAAE,KAAK,SAAS;YAAE,SAAS;QAC/B,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;YACjB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC;gBAC5B,OAAO,EAAE,sBAAsB,EAAE,cAAc,IAAI,CAAC,EAAE,GAAG;aAC1D,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAKL;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KACjC,KAAK,CAAC,kBAAkB,CAAC;KACzB,WAAW,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;IAC1B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACrD,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;QAC5B,IAAI,EAAE,KAAK,SAAS;YAAE,SAAS;QAC/B,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;YACjB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;gBACnB,OAAO,EAAE,+BAA+B,EAAE,+CAA+C;aAC1F,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAKL,gDAAgD;AAChD,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAE1C;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,IAAkB;IACxC,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9E,OAAO,CAAC,EAAE,EAAE,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;AAC1D,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC;KACtC,MAAM,CAAC;IACN,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;CACnC,CAAC;KACD,MAAM,EAAE,CAAC;AAkCZ;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAgE,MAAM,CAAC,MAAM,CAAC;IACjH,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC;QACjB,EAAE,EAAE,KAAK;QACT,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,YAAY;QACpB,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;QAC7D,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,CAAC;QACnF,cAAc,EAAE,SAAS;QACzB,sBAAsB,EAAE,KAAK;QAC7B,OAAO,EAAE,YAAY;KACtB,CAAC;IACF,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;QACpB,EAAE,EAAE,QAAQ;QACZ,KAAK,EAAE,QAAQ;QACf,MAAM,EAAE,QAAQ;QAChB,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;QACnE,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;QACvG,cAAc,EAAE,WAAW;QAC3B,sBAAsB,EAAE,IAAI;QAC5B,OAAO,EAAE,QAAQ;KAClB,CAAC;CACH,CAAC,CAAC;AAEH,kEAAkE;AAClE,MAAM,UAAU,oBAAoB;IAClC,OAAO,CAAC,GAAG,wBAAwB,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,wBAAwB,CAAC,EAAE,CAAC,CAAC,CAAC;AACxF,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAU,CAAC;AAKnH;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAE1C,yDAAyD;AACzD,MAAM,CAAC,MAAM,8BAA8B,GAAG,kBAAkB,CAAC"}

package/dist/schemas/classification-policy.d.ts

@@ -124,13 +124,55 @@ export declare const CoverageRuleSchema: z.ZodObject<{
 /** Inferred coverage-rule shape. */
 export type CoverageRule = z.infer<typeof CoverageRuleSchema>;
 /**
- * The classification-policy document: scan roots (complete-scan scope),
- * trusted internal entry-point categories, organization internal rules,
- * the supported source declaration syntax, and volatile fields.
+ * One owner-declared PLANE rule list — the `planes:` section of the
+ * answers document (0.11.0, was `.gateforge/planes.json`). The section
+ * keeps the document shape it always had (`{ rules: [...] }`) so
+ * `gateforge migrate` is a pure text move, but the RULES themselves stay
+ * validated by the pack that applies them (one validation source, the
+ * same fail-closed reader that has always guarded them): this schema
+ * rejects a wrong document SHAPE and the owning reader rejects a wrong
+ * rule. Absent = no plane channel, byte-identical to today.
+ */
+export declare const PlanesSectionSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+/** Inferred `planes:` section shape. */
+export type PlanesSection = z.infer<typeof PlanesSectionSchema>;
+/**
+ * One owner-declared ENDPOINT-CAPABILITY rule list — the `endpoints:`
+ * section of the answers document (0.11.0, was `.gateforge/endpoints.json`).
+ * Same posture as {@link PlanesSectionSchema}: shape here, rules validated
+ * by the endpoint compiler that applies them.
+ */
+export declare const EndpointsSectionSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+/** Inferred `endpoints:` section shape. */
+export type EndpointsSection = z.infer<typeof EndpointsSectionSchema>;
+/**
+ * Repo-root-relative location of the ONE owner-answers document. Named
+ * once, in the package that owns the document, so every diagnostic that
+ * has to point the owner at a declaration — the refusals, the migrator,
+ * the packs — names the same path.
+ */
+export declare const OWNER_ANSWERS_PATH = ".gateforge/classification-policy.yml";
+/**
+ * The classification-policy document: the ONE owner-answers file
+ * (`.gateforge/classification-policy.yml`, name kept by owner decision).
+ * Since 0.11.0 it holds every owner answer — trusted internal
+ * entry-point categories, organization internal rules, exact lifecycle
+ * disables, delete semantics, plane rules, endpoint capabilities, and
+ * the owner's business `rules:`.
+ *
+ * The SCANNER settings (`scanRoots`, `coverage`, `declarations`,
+ * `volatileFields`) MOVED OUT to `.gateforge.yml` under `scan:`, next to
+ * the other machine-wide declarations. They are no longer accepted here:
+ * a repository still carrying them fails closed naming `gateforge
+ * migrate` rather than silently running on a setting the engine cannot
+ * see.
  */
 export declare const ClassificationPolicySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
-    scanRoots: z.ZodArray<z.ZodString>;
     trustedInternalEntryPoints: z.ZodArray<z.ZodObject<{
         category: z.ZodString;
         patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -164,14 +206,35 @@ export declare const ClassificationPolicySchema: z.ZodObject<{
         archiveFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
         reason: z.ZodString;
     }, z.core.$strict>>>;
-    coverage: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        capability: z.ZodString;
-        detector: z.ZodString;
-        appliesTo: z.ZodArray<z.ZodString>;
-        exhaustive: z.ZodOptional<z.ZodBoolean>;
+    planes: z.ZodOptional<z.ZodObject<{
+        rules: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    endpoints: z.ZodOptional<z.ZodObject<{
+        rules: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        describe: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        test: z.ZodDefault<z.ZodEnum<{
+            e2e: "e2e";
+            pytest: "pytest";
+        }>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            block: "block";
+            advisory: "advisory";
+        }>>;
+        advisoryReason: z.ZodOptional<z.ZodString>;
+        cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            describe: z.ZodString;
+        }, z.core.$strict>>>;
+        hints: z.ZodOptional<z.ZodObject<{
+            routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>>;
-    declarations: z.ZodRecord<z.ZodString, z.ZodString>;
-    volatileFields: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 /** Inferred classification-policy shape. */
 export type ClassificationPolicy = z.infer<typeof ClassificationPolicySchema>;

package/dist/schemas/classification-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classification-policy.d.ts","sourceRoot":"","sources":["../../src/schemas/classification-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,wEAAwE;AACxE,eAAO,MAAM,gCAAgC;;;;kBAmBlC,CAAC;AAEZ,oDAAoD;AACpD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,oEAAoE;AACpE,eAAO,MAAM,uBAAuB;;;kBAUhC,CAAC;AAEL,0CAA0C;AAC1C,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,qFAAqF;AACrF,eAAO,MAAM,kBAAkB;;;;;;kBAOpB,CAAC;AAEZ,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,iDAAkD,CAAC;AAEpF,gDAAgD;AAChD,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAiBvE,wDAAwD;AACxD,eAAO,MAAM,wBAAwB;;kBAK1B,CAAC;AAEZ,2CAA2C;AAC3C,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,kFAAkF;AAClF,eAAO,MAAM,mBAAmB;;;;;;;;;;;kBAkCrB,CAAC;AAEZ,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;mBAoB7B,CAAC;AAEL,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,aAAa,EAAE,CAQnF;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;EAA8B,CAAC;AAEjE,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AA6BpE,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;;;;;;kBA4CzB,CAAC;AAEL,kCAAkC;AAClC,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,wEAAwE;AACxE,eAAO,MAAM,iBAAiB;;;;;;;;mBAoB1B,CAAC;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;kBAyBpB,CAAC;AAEZ,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4C5B,CAAC;AAEZ,4CAA4C;AAC5C,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}
+{"version":3,"file":"classification-policy.d.ts","sourceRoot":"","sources":["../../src/schemas/classification-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,wEAAwE;AACxE,eAAO,MAAM,gCAAgC;;;;kBAmBlC,CAAC;AAEZ,oDAAoD;AACpD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,oEAAoE;AACpE,eAAO,MAAM,uBAAuB;;;kBAUhC,CAAC;AAEL,0CAA0C;AAC1C,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,qFAAqF;AACrF,eAAO,MAAM,kBAAkB;;;;;;kBAOpB,CAAC;AAEZ,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,iDAAkD,CAAC;AAEpF,gDAAgD;AAChD,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAiBvE,wDAAwD;AACxD,eAAO,MAAM,wBAAwB;;kBAK1B,CAAC;AAEZ,2CAA2C;AAC3C,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,kFAAkF;AAClF,eAAO,MAAM,mBAAmB;;;;;;;;;;;kBAkCrB,CAAC;AAEZ,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;mBAoB7B,CAAC;AAEL,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,aAAa,EAAE,CAQnF;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;EAA8B,CAAC;AAEjE,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AA6BpE,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;;;;;;kBA4CzB,CAAC;AAEL,kCAAkC;AAClC,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,wEAAwE;AACxE,eAAO,MAAM,iBAAiB;;;;;;;;mBAoB1B,CAAC;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;kBAyBpB,CAAC;AAEZ,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB;;kBAKrB,CAAC;AAEZ,wCAAwC;AACxC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;kBAKxB,CAAC;AAEZ,2CAA2C;AAC3C,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,yCAAyC,CAAC;AAEzE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgC5B,CAAC;AAEZ,4CAA4C;AAC5C,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}