@agentplat/mesh-conformance 0.3.0-beta.1 → 0.3.0-beta.4

package/dist/planning.d.ts.map

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

package/dist/planning.js

@@ -0,0 +1,656 @@
+import { canonicalizePlanningJsonV1, deepFreezePlanning, sha256HexPlanningV1, } from "@agentplat/collective-planning";
+import { awaitConformanceOperation, MeshConformanceCleanupError, runConformanceCleanup, } from "./runner.js";
+/** Version of the portable planning conformance contract. */
+export const PLANNING_CONFORMANCE_VERSION_V1 = 1;
+/**
+ * Closed declarations. A declaration states which public case groups were
+ * executed; it never grants authority to a planner or its runner.
+ */
+export const PLANNING_CONFORMANCE_CAPABILITIES_V1 = Object.freeze([
+    "planning.portable",
+    "planning.reducer",
+    "planning.snapshot",
+    "planning.replanning",
+    "planning.fencing",
+    "planning.mesh-projection",
+    "planning.evaluation",
+    "planning.durable",
+]);
+export const PLANNING_REQUIRED_CONFORMANCE_CAPABILITIES_V1 = Object.freeze([
+    "planning.portable",
+    "planning.reducer",
+]);
+/** The complete public suite. Case identifiers and capability membership are closed. */
+export const PLANNING_CONFORMANCE_CASES_V1 = Object.freeze([
+    define("planning.intent.closed-record", "planning.portable", "rejected", "unknown_field"),
+    define("planning.proposal.scope-widening", "planning.portable", "rejected", "scope_widening"),
+    define("planning.reducer.dependency-cycle", "planning.reducer", "rejected", "dependency_cycle"),
+    define("planning.reducer.exact-replay", "planning.reducer", "accepted", null),
+    define("planning.snapshot.cross-scope", "planning.snapshot", "rejected", "snapshot_scope_mismatch"),
+    define("planning.snapshot.rollback", "planning.snapshot", "rejected", "snapshot_rollback"),
+    define("planning.replanning.causal-predecessor", "planning.replanning", "rejected", "causal_predecessor_missing"),
+    define("planning.fencing.stale-result", "planning.fencing", "rejected", "stale_fence"),
+    define("planning.mesh-projection.assignment-bound", "planning.mesh-projection", "rejected", "assignment_binding_mismatch"),
+    define("planning.evaluation.public-artifact", "planning.evaluation", "rejected", "private_evidence_disclosed"),
+    define("planning.durable.restart-high-water", "planning.durable", "accepted", null),
+]);
+/** Stable commitment to the public case definitions. */
+export const PLANNING_CONFORMANCE_SUITE_DIGEST_V1 = commitment({
+    schemaVersion: 1,
+    cases: PLANNING_CONFORMANCE_CASES_V1.map((entry) => ({ ...entry })),
+});
+/**
+ * Runs every case against a fresh caller-supplied adapter. No adapter is
+ * allowed to share implicit state between cases, and undeclared groups are
+ * recorded instead of silently omitted.
+ */
+export async function runPlanningConformanceV1(options) {
+    const normalizedOptions = normalizePlanningOptions(options);
+    const context = planningRunnerContext(normalizedOptions);
+    const capabilities = normalizeCapabilities(normalizedOptions.declaredCapabilities);
+    for (const capability of PLANNING_REQUIRED_CONFORMANCE_CAPABILITIES_V1) {
+        if (!capabilities.has(capability)) {
+            throw new TypeError("Required planning conformance capability is missing");
+        }
+    }
+    const fixtures = createPlanningConformanceFixturesV1();
+    return Object.freeze(await Promise.all(PLANNING_CONFORMANCE_CASES_V1.map(async (definition) => {
+        const challenge = fixtures.get(definition.caseId);
+        if (!capabilities.has(definition.capability)) {
+            return result(definition, "not_declared", null, 0, challenge.fixtureDigest, null);
+        }
+        let assessment;
+        const bounded = await runPlanningBoundedCase({
+            context,
+            run: async (signal) => {
+                const adapter = await awaitConformanceOperation(normalizedOptions.factory(Object.freeze({ seed: context.seed, signal })), signal);
+                assertAdapter(adapter);
+                let failure;
+                try {
+                    assessment = validatePlanningConformanceAssessmentV1(await awaitConformanceOperation(adapter.assess(challenge, signal), signal));
+                    assertAssessment(definition, challenge, assessment);
+                }
+                catch (error) {
+                    failure = error;
+                }
+                await runConformanceCleanup(adapter.cleanup?.bind(adapter), context.cleanupTimeoutMs, failure);
+                if (failure !== undefined)
+                    throw failure;
+            },
+        });
+        return result(definition, bounded.outcome === "passed" ? "passed" : "failed", bounded.outcome === "passed"
+            ? null
+            : (bounded.reasonCode ?? "assertion_failed"), bounded.durationMs, challenge.fixtureDigest, bounded.outcome === "passed"
+            ? (assessment?.evidenceDigest ?? null)
+            : null);
+    })));
+}
+function normalizePlanningOptions(input) {
+    const value = exactOptionRecord(input);
+    if (typeof value.factory !== "function") {
+        throw new TypeError("Planning conformance factory is required");
+    }
+    return Object.freeze({
+        factory: value.factory,
+        declaredCapabilities: value.declaredCapabilities,
+        ...(value.seed === undefined ? {} : { seed: value.seed }),
+        ...(value.timeoutMs === undefined
+            ? {}
+            : { timeoutMs: value.timeoutMs }),
+        ...(value.totalTimeoutMs === undefined
+            ? {}
+            : { totalTimeoutMs: value.totalTimeoutMs }),
+        ...(value.cleanupTimeoutMs === undefined
+            ? {}
+            : { cleanupTimeoutMs: value.cleanupTimeoutMs }),
+        ...(value.signal === undefined
+            ? {}
+            : { signal: value.signal }),
+        ...(value.clock === undefined
+            ? {}
+            : { clock: value.clock }),
+    });
+}
+function exactOptionRecord(input) {
+    if (!input ||
+        typeof input !== "object" ||
+        Array.isArray(input) ||
+        (Object.getPrototypeOf(input) !== Object.prototype &&
+            Object.getPrototypeOf(input) !== null) ||
+        Object.getOwnPropertySymbols(input).length !== 0)
+        throw new TypeError("Planning conformance options are invalid");
+    const required = ["declaredCapabilities", "factory"];
+    const permitted = [
+        ...required,
+        "cleanupTimeoutMs",
+        "clock",
+        "seed",
+        "signal",
+        "timeoutMs",
+        "totalTimeoutMs",
+    ];
+    const names = Object.getOwnPropertyNames(input);
+    if (names.some((name) => !permitted.includes(name)) ||
+        required.some((name) => !names.includes(name)))
+        throw new TypeError("Planning conformance options have unknown fields");
+    const result = Object.create(null);
+    for (const name of names) {
+        const descriptor = Object.getOwnPropertyDescriptor(input, name);
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) {
+            throw new TypeError("Planning conformance options have accessors");
+        }
+        result[name] = descriptor.value;
+    }
+    return Object.freeze(result);
+}
+function planningRunnerContext(options) {
+    const seed = integer(options.seed ?? 0, "seed", 0, 0xffff_ffff);
+    const timeoutMs = integer(options.timeoutMs ?? 5_000, "timeout", 10, 60_000);
+    const totalTimeoutMs = integer(options.totalTimeoutMs ?? 60_000, "suite timeout", 10, 300_000);
+    const cleanupTimeoutMs = integer(options.cleanupTimeoutMs ?? 2_000, "cleanup timeout", 10, 30_000);
+    if (options.signal !== undefined &&
+        !(options.signal instanceof AbortSignal)) {
+        throw new TypeError("Planning conformance abort signal is invalid");
+    }
+    if (options.clock !== undefined && typeof options.clock !== "function") {
+        throw new TypeError("Planning conformance clock is invalid");
+    }
+    return Object.freeze({
+        seed,
+        timeoutMs,
+        cleanupTimeoutMs,
+        deadline: monotonicNow() + totalTimeoutMs,
+        signal: options.signal,
+        clock: options.clock ?? Date.now,
+    });
+}
+async function runPlanningBoundedCase(input) {
+    const started = input.context.clock();
+    const remaining = Math.trunc(input.context.deadline - monotonicNow());
+    if (remaining <= 0)
+        return Object.freeze({
+            outcome: "failed",
+            reasonCode: "suite_timeout",
+            durationMs: 0,
+        });
+    const controller = new AbortController();
+    const relay = () => controller.abort(new PlanningConformanceAbort("aborted"));
+    input.context.signal?.addEventListener("abort", relay, { once: true });
+    let timer;
+    try {
+        if (input.context.signal?.aborted)
+            throw new PlanningConformanceAbort("aborted");
+        const timeoutReason = remaining <= input.context.timeoutMs ? "suite_timeout" : "timeout";
+        timer = setTimeout(() => controller.abort(new PlanningConformanceAbort(timeoutReason)), Math.min(remaining, input.context.timeoutMs));
+        await input.run(controller.signal);
+        if (controller.signal.aborted)
+            throw controller.signal.reason;
+        return Object.freeze({
+            outcome: "passed",
+            reasonCode: null,
+            durationMs: duration(started, input.context.clock()),
+        });
+    }
+    catch (error) {
+        return Object.freeze({
+            outcome: "failed",
+            reasonCode: planningFailureCode(error),
+            durationMs: duration(started, input.context.clock()),
+        });
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        input.context.signal?.removeEventListener("abort", relay);
+    }
+}
+class PlanningConformanceAbort extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+function planningFailureCode(error) {
+    if (error instanceof PlanningConformanceAbort)
+        return error.code;
+    if (error instanceof MeshConformanceCleanupError) {
+        return error.previousFailure instanceof PlanningConformanceAbort
+            ? `${error.previousFailure.code}_cleanup_failed`
+            : "cleanup_failed";
+    }
+    return "assertion_failed";
+}
+function duration(started, ended) {
+    const value = Math.max(0, Math.trunc(ended - started));
+    return Number.isSafeInteger(value) ? Math.min(value, 60_000) : 60_000;
+}
+function monotonicNow() {
+    return globalThis.performance?.now() ?? Date.now();
+}
+/** Builds a sealed, canonical public report from a complete suite execution. */
+export function createPlanningConformanceReportV1(input) {
+    exactRecord(input, [
+        "cases",
+        "declaredCapabilities",
+        "implementation",
+        "seed",
+    ]);
+    const capabilities = [
+        ...normalizeCapabilities(input.declaredCapabilities),
+    ].sort(compareAscii);
+    for (const capability of PLANNING_REQUIRED_CONFORMANCE_CAPABILITIES_V1) {
+        if (!capabilities.includes(capability))
+            throw new TypeError("Required planning conformance capability is missing");
+    }
+    const implementation = normalizeImplementation(input.implementation);
+    const seed = integer(input.seed, "seed", 0, 0xffff_ffff);
+    const cases = normalizeResults(input.cases, new Set(capabilities));
+    const counts = Object.freeze({
+        passed: cases.filter((entry) => entry.outcome === "passed").length,
+        failed: cases.filter((entry) => entry.outcome === "failed").length,
+        notDeclared: cases.filter((entry) => entry.outcome === "not_declared")
+            .length,
+        total: cases.length,
+    });
+    return Object.freeze({
+        schemaVersion: 1,
+        conformanceVersion: PLANNING_CONFORMANCE_VERSION_V1,
+        suiteDigest: PLANNING_CONFORMANCE_SUITE_DIGEST_V1,
+        fixtureManifestDigest: planningConformanceFixtureManifestDigestV1(),
+        implementation,
+        declaredCapabilities: Object.freeze(capabilities),
+        seed,
+        cases,
+        counts,
+        verdict: counts.failed === 0 ? "passed" : "failed",
+    });
+}
+/** Rejects a tampered, incomplete, undisclosed-capability or aggregate-inconsistent report. */
+export function validatePlanningConformanceReportV1(value) {
+    exactRecord(value, [
+        "cases",
+        "conformanceVersion",
+        "counts",
+        "declaredCapabilities",
+        "fixtureManifestDigest",
+        "implementation",
+        "schemaVersion",
+        "seed",
+        "suiteDigest",
+        "verdict",
+    ]);
+    const report = value;
+    if (report.schemaVersion !== 1 ||
+        report.conformanceVersion !== PLANNING_CONFORMANCE_VERSION_V1 ||
+        report.suiteDigest !== PLANNING_CONFORMANCE_SUITE_DIGEST_V1 ||
+        report.fixtureManifestDigest !==
+            planningConformanceFixtureManifestDigestV1())
+        throw new TypeError("Planning conformance report binding is invalid");
+    const normalized = createPlanningConformanceReportV1({
+        implementation: report.implementation,
+        declaredCapabilities: report.declaredCapabilities,
+        seed: report.seed,
+        cases: report.cases,
+    });
+    exactRecord(report.counts, ["failed", "notDeclared", "passed", "total"]);
+    if (report.counts.passed !== normalized.counts.passed ||
+        report.counts.failed !== normalized.counts.failed ||
+        report.counts.notDeclared !== normalized.counts.notDeclared ||
+        report.counts.total !== normalized.counts.total ||
+        report.verdict !== normalized.verdict)
+        throw new TypeError("Planning conformance report aggregate is inconsistent");
+    return normalized;
+}
+/** Public deterministic fixtures; each one is a bounded, redacted challenge. */
+export function createPlanningConformanceFixturesV1() {
+    const fixtures = PLANNING_CONFORMANCE_CASES_V1.map((definition) => {
+        const input = deepFreezePlanning(fixtureInput(definition.caseId));
+        return deepFreezePlanning({
+            schemaVersion: 1,
+            caseId: definition.caseId,
+            fixtureDigest: commitment({
+                schemaVersion: 1,
+                caseId: definition.caseId,
+                input,
+            }),
+            input,
+        });
+    });
+    return new Map(fixtures.map((fixture) => [fixture.caseId, fixture]));
+}
+export function planningConformanceFixtureManifestDigestV1() {
+    const fixtures = createPlanningConformanceFixturesV1();
+    return commitment({
+        schemaVersion: 1,
+        fixtures: PLANNING_CONFORMANCE_CASES_V1.map((definition) => ({
+            caseId: definition.caseId,
+            fixtureDigest: fixtures.get(definition.caseId).fixtureDigest,
+        })),
+    });
+}
+function fixtureInput(caseId) {
+    const common = { schemaVersion: 1, fixtureVersion: 1 };
+    switch (caseId) {
+        case "planning.intent.closed-record":
+            return Object.freeze({
+                ...common,
+                operation: "intent.validate",
+                intent: {
+                    missionIntentId: "mission:planning-conformance",
+                    revision: 1,
+                },
+                injectedAuthority: "must-not-be-accepted",
+            });
+        case "planning.proposal.scope-widening":
+            return Object.freeze({
+                ...common,
+                operation: "proposal.validate",
+                permittedCapabilityKeys: ["documents.write"],
+                proposalCapabilityKeys: ["documents.write", "root.admin"],
+            });
+        case "planning.reducer.dependency-cycle":
+            return Object.freeze({
+                ...common,
+                operation: "reducer.apply",
+                fragments: [
+                    { fragmentId: "fragment:a", dependencies: ["fragment:b"] },
+                    { fragmentId: "fragment:b", dependencies: ["fragment:a"] },
+                ],
+            });
+        case "planning.reducer.exact-replay":
+            return Object.freeze({
+                ...common,
+                operation: "reducer.replay",
+                commands: [
+                    {
+                        commandId: "command:1",
+                        logicalTimeMs: 1,
+                        kind: "observation.record",
+                    },
+                    {
+                        commandId: "command:1",
+                        logicalTimeMs: 1,
+                        kind: "observation.record",
+                    },
+                ],
+            });
+        case "planning.snapshot.cross-scope":
+            return Object.freeze({
+                ...common,
+                operation: "snapshot.restore",
+                snapshotScope: "tenant:one/policy:a/mission:one",
+                targetScope: "tenant:two/policy:a/mission:one",
+                snapshotGeneration: 4,
+                targetHighWater: 4,
+            });
+        case "planning.snapshot.rollback":
+            return Object.freeze({
+                ...common,
+                operation: "snapshot.restore",
+                snapshotScope: "tenant:one/policy:a/mission:one",
+                targetScope: "tenant:one/policy:a/mission:one",
+                snapshotGeneration: 3,
+                targetHighWater: 4,
+            });
+        case "planning.replanning.causal-predecessor":
+            return Object.freeze({
+                ...common,
+                operation: "replanning.apply",
+                triggerObservationDigest: null,
+                predecessorPlanDigest: null,
+                revisedPlanDigest: "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+            });
+        case "planning.fencing.stale-result":
+            return Object.freeze({
+                ...common,
+                operation: "effect.apply",
+                currentFence: "fence:2",
+                resultFence: "fence:1",
+                workId: "work:planning-conformance",
+            });
+        case "planning.mesh-projection.assignment-bound":
+            return Object.freeze({
+                ...common,
+                operation: "mesh-projection.validate",
+                assignmentDigest: "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+                extensionAssignmentDigest: "sha256:abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789",
+            });
+        case "planning.evaluation.public-artifact":
+            return Object.freeze({
+                ...common,
+                operation: "evaluation.artifact.validate",
+                artifact: {
+                    traceDigest: "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+                },
+                privateEvidence: "must-not-be-disclosed",
+            });
+        case "planning.durable.restart-high-water":
+            return Object.freeze({
+                ...common,
+                operation: "durability.reopen",
+                scope: "tenant:one/policy:a/mission:one",
+                expectedStateDigest: "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+                expectedFenceHighWater: 2,
+            });
+    }
+}
+export function validatePlanningConformanceAssessmentV1(value) {
+    exactRecord(value, [
+        "caseId",
+        "evidenceDigest",
+        "fixtureDigest",
+        "reasonCode",
+        "schemaVersion",
+        "verdict",
+    ]);
+    const assessment = value;
+    if (assessment.schemaVersion !== 1 ||
+        !caseDefinition(assessment.caseId) ||
+        !isDigest(assessment.fixtureDigest) ||
+        !isDigest(assessment.evidenceDigest) ||
+        !["accepted", "rejected"].includes(assessment.verdict) ||
+        (assessment.reasonCode !== null && !isReason(assessment.reasonCode)))
+        throw new TypeError("Planning conformance assessment is invalid");
+    return Object.freeze({ ...assessment });
+}
+function assertAssessment(definition, challenge, assessment) {
+    if (assessment.caseId !== definition.caseId ||
+        assessment.fixtureDigest !== challenge.fixtureDigest ||
+        assessment.verdict !== definition.expectedVerdict ||
+        assessment.reasonCode !== definition.expectedReasonCode)
+        throw new TypeError("Planning conformance assessment does not match public fixture");
+}
+function normalizeResults(values, capabilities) {
+    const candidates = ownArrayValues(values, PLANNING_CONFORMANCE_CASES_V1.length, "case results");
+    if (candidates.length !== PLANNING_CONFORMANCE_CASES_V1.length) {
+        throw new TypeError("Planning conformance case coverage is incomplete");
+    }
+    const fixtures = createPlanningConformanceFixturesV1();
+    const byId = new Map();
+    for (const candidate of candidates) {
+        exactRecord(candidate, [
+            "capability",
+            "caseId",
+            "durationMs",
+            "evidenceDigest",
+            "fixtureDigest",
+            "outcome",
+            "reasonCode",
+        ]);
+        const result = candidate;
+        if (byId.has(result.caseId))
+            throw new TypeError("Planning conformance case is duplicated");
+        byId.set(result.caseId, result);
+    }
+    return Object.freeze(PLANNING_CONFORMANCE_CASES_V1.map((definition) => {
+        const value = byId.get(definition.caseId);
+        if (!value)
+            throw new TypeError("Planning conformance case is missing");
+        const declared = capabilities.has(definition.capability);
+        if (value.caseId !== definition.caseId ||
+            value.capability !== definition.capability ||
+            !["passed", "failed", "not_declared"].includes(value.outcome) ||
+            !Number.isSafeInteger(value.durationMs) ||
+            value.durationMs < 0 ||
+            value.durationMs > 60_000 ||
+            value.fixtureDigest !==
+                fixtures.get(definition.caseId).fixtureDigest ||
+            (value.reasonCode !== null && !isReason(value.reasonCode)) ||
+            (value.evidenceDigest !== null && !isDigest(value.evidenceDigest)) ||
+            (!declared &&
+                (value.outcome !== "not_declared" ||
+                    value.reasonCode !== null ||
+                    value.evidenceDigest !== null)) ||
+            (declared && value.outcome === "not_declared") ||
+            (value.outcome === "passed" &&
+                (value.reasonCode !== null || value.evidenceDigest === null)) ||
+            (value.outcome === "failed" &&
+                (value.reasonCode === null || value.evidenceDigest !== null)))
+            throw new TypeError("Planning conformance case result is invalid");
+        return Object.freeze({ ...value });
+    }));
+}
+function result(definition, outcome, reasonCode, durationMs, fixtureDigest, evidenceDigest) {
+    return Object.freeze({
+        caseId: definition.caseId,
+        capability: definition.capability,
+        outcome,
+        reasonCode,
+        durationMs,
+        fixtureDigest,
+        evidenceDigest,
+    });
+}
+function normalizeCapabilities(values) {
+    const candidateValues = ownArrayValues(values, PLANNING_CONFORMANCE_CAPABILITIES_V1.length, "capabilities");
+    if (candidateValues.length > PLANNING_CONFORMANCE_CAPABILITIES_V1.length) {
+        throw new RangeError("Planning conformance capability count is invalid");
+    }
+    const result = new Set();
+    for (const candidate of candidateValues) {
+        if (typeof candidate !== "string") {
+            throw new TypeError("Planning conformance capability is invalid");
+        }
+        const value = candidate;
+        if (!PLANNING_CONFORMANCE_CAPABILITIES_V1.includes(value) ||
+            result.has(value)) {
+            throw new TypeError("Planning conformance capability is invalid");
+        }
+        result.add(value);
+    }
+    return result;
+}
+function normalizeImplementation(value) {
+    exactRecord(value, ["name", "version"]);
+    if (!isText(value.name, 128) ||
+        !/^[0-9A-Za-z][0-9A-Za-z.+-]{0,63}$/u.test(value.version)) {
+        throw new TypeError("Planning conformance implementation is invalid");
+    }
+    return Object.freeze({ name: value.name, version: value.version });
+}
+function assertAdapter(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        (Object.getPrototypeOf(value) !== Object.prototype &&
+            Object.getPrototypeOf(value) !== null) ||
+        Object.getOwnPropertySymbols(value).length !== 0)
+        throw new TypeError("Planning conformance factory is invalid");
+    const names = Object.getOwnPropertyNames(value).sort(compareAscii);
+    if (names.length < 1 ||
+        names.length > 2 ||
+        names[0] !== "assess" ||
+        (names.length === 2 && names[1] !== "cleanup"))
+        throw new TypeError("Planning conformance factory is invalid");
+    const assess = Object.getOwnPropertyDescriptor(value, "assess");
+    const cleanup = Object.getOwnPropertyDescriptor(value, "cleanup");
+    if (!assess ||
+        !assess.enumerable ||
+        !("value" in assess) ||
+        typeof assess.value !== "function" ||
+        (cleanup !== undefined &&
+            (!cleanup.enumerable ||
+                !("value" in cleanup) ||
+                (cleanup.value !== undefined && typeof cleanup.value !== "function"))))
+        throw new TypeError("Planning conformance factory is invalid");
+}
+function define(caseId, capability, expectedVerdict, expectedReasonCode) {
+    return Object.freeze({
+        caseId,
+        capability,
+        expectedVerdict,
+        expectedReasonCode,
+    });
+}
+function caseDefinition(value) {
+    return PLANNING_CONFORMANCE_CASES_V1.find((definition) => definition.caseId === value);
+}
+function commitment(value) {
+    const encoded = new TextEncoder().encode(`agentplat.mesh-conformance/planning/v1\0${canonicalizePlanningJsonV1(value)}`);
+    return `sha256:${sha256HexPlanningV1(encoded)}`;
+}
+function exactRecord(value, keys) {
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        (Object.getPrototypeOf(value) !== Object.prototype &&
+            Object.getPrototypeOf(value) !== null) ||
+        Object.getOwnPropertySymbols(value).length !== 0)
+        throw new TypeError("Planning conformance record is invalid");
+    const actual = Object.getOwnPropertyNames(value).sort(compareAscii);
+    const expected = [...keys].sort(compareAscii);
+    if (actual.length !== expected.length ||
+        actual.some((key, index) => key !== expected[index])) {
+        throw new TypeError("Planning conformance record has unknown fields");
+    }
+    for (const key of actual) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) {
+            throw new TypeError("Planning conformance record has accessors");
+        }
+    }
+}
+function ownArrayValues(value, maximum, label) {
+    if (!Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Array.prototype ||
+        value.length > maximum ||
+        Object.getOwnPropertySymbols(value).length !== 0)
+        throw new TypeError(`Planning conformance ${label} are invalid`);
+    const result = [];
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length !== value.length + 1 || !names.includes("length")) {
+        throw new TypeError(`Planning conformance ${label} are sparse`);
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) {
+            throw new TypeError(`Planning conformance ${label} have accessors`);
+        }
+        result.push(descriptor.value);
+    }
+    return Object.freeze(result);
+}
+function integer(value, label, minimum, maximum) {
+    if (!Number.isSafeInteger(value) ||
+        value < minimum ||
+        value > maximum) {
+        throw new RangeError(`Planning conformance ${label} is invalid`);
+    }
+    return value;
+}
+function isDigest(value) {
+    return typeof value === "string" && /^sha256:[a-f0-9]{64}$/u.test(value);
+}
+function isReason(value) {
+    return typeof value === "string" && /^[a-z][a-z0-9._:-]{0,63}$/u.test(value);
+}
+function isText(value, maximum) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        new TextEncoder().encode(value).byteLength <= maximum &&
+        !/[\u0000-\u001f\u007f]/u.test(value));
+}
+function compareAscii(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+//# sourceMappingURL=planning.js.map