project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/symbolic-denotation-runtime.js

@@ -0,0 +1,90 @@
+import { compareText, invalid } from "./symbolic-denotation-support.js";
+export function buildSymbolicRuntimeAxes(domains, numberCuts) {
+    return domains.map((domain) => {
+        if (domain.kind === "enum")
+            return {
+                domain,
+                segments: domain.values.map((value) => ({
+                    kind: "enum",
+                    values: [value],
+                })),
+            };
+        return { domain, segments: buildNumberSegments(domain, numberCuts) };
+    });
+}
+function buildNumberSegments(domain, numberCuts) {
+    const cuts = new Set([
+        domain.minimum,
+        domain.maximum + 1,
+        ...(numberCuts.get(domain.key) ?? []),
+    ]);
+    const sorted = [...cuts]
+        .filter((value) => value >= domain.minimum && value <= domain.maximum + 1)
+        .sort((left, right) => left - right);
+    const segments = [];
+    for (let index = 0; index < sorted.length - 1; index += 1) {
+        const minimum = sorted[index];
+        const maximum = sorted[index + 1] - 1;
+        if (minimum <= maximum)
+            segments.push({ kind: "number", minimum, maximum });
+    }
+    return segments;
+}
+export function canonicalSymbolicEdges(axis, childRefs) {
+    return axis.domain.kind === "enum"
+        ? canonicalEnumEdges(axis, childRefs)
+        : canonicalNumberEdges(axis, childRefs);
+}
+function canonicalEnumEdges(axis, childRefs) {
+    const groups = new Map();
+    axis.segments.forEach((segment, index) => {
+        const values = groups.get(childRefs[index]) ?? [];
+        values.push(...segment.values);
+        groups.set(childRefs[index], values);
+    });
+    return [...groups.entries()]
+        .map(([child_ref, values]) => ({
+        region: { kind: "enum_set", values },
+        child_ref,
+    }))
+        .sort((left, right) => compareText(left.region.values[0], right.region.values[0]));
+}
+function canonicalNumberEdges(axis, childRefs) {
+    const edges = [];
+    axis.segments.forEach((segment, index) => {
+        const numeric = segment;
+        const previous = edges.at(-1);
+        if (previous?.region.kind === "integer_range" &&
+            previous.child_ref === childRefs[index] &&
+            previous.region.maximum + 1 === numeric.minimum) {
+            previous.region.maximum = numeric.maximum;
+            return;
+        }
+        edges.push({
+            region: {
+                kind: "integer_range",
+                minimum: numeric.minimum,
+                maximum: numeric.maximum,
+            },
+            child_ref: childRefs[index],
+        });
+    });
+    return edges;
+}
+export function symbolicEdgeMatches(edge, value) {
+    if (edge.region.kind === "enum_set")
+        return typeof value === "string" && edge.region.values.includes(value);
+    return (typeof value === "number" &&
+        Number.isSafeInteger(value) &&
+        value >= edge.region.minimum &&
+        value <= edge.region.maximum);
+}
+export function symbolicSegmentMatches(segment, matches) {
+    if (segment.kind === "enum")
+        return matches(segment.values[0]);
+    const atMinimum = matches(segment.minimum);
+    const atMaximum = matches(segment.maximum);
+    if (atMinimum !== atMaximum)
+        invalid("numeric_partition_not_theory_complete", `${segment.minimum}:${segment.maximum}`);
+    return atMinimum;
+}

package/dist/lib/symbolic-denotation-support.d.ts

@@ -0,0 +1,11 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
+export declare function exactKeys(value: object, expected: string[], label: string): void;
+export declare function stableKey(value: unknown, label: string): asserts value is string;
+export declare function stableJson(value: unknown): string;
+export declare function sha256(value: string): string;
+export declare function compareText(left: string, right: string): number;
+export declare function compareScalar(left: SymbolicDenotationScalar, right: SymbolicDenotationScalar): number;
+export declare function scalarEqual(left: SymbolicDenotationScalar, right: SymbolicDenotationScalar): boolean;
+export declare function domainCardinality(domain: SymbolicDenotationAxisDomain): bigint;
+export declare function neverValue(value: never): string;
+export declare function invalid(code: string, detail: string): never;

package/dist/lib/symbolic-denotation-support.js

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto";
+export function exactKeys(value, expected, label) {
+    const actual = Object.keys(value).sort(compareText);
+    const required = [...expected].sort(compareText);
+    if (actual.length !== required.length ||
+        actual.some((key, index) => key !== required[index]))
+        invalid("shape_keys_invalid", `${label}:actual=${actual.join(",")}:expected=${required.join(",")}`);
+}
+export function stableKey(value, label) {
+    if (typeof value !== "string" || !/^[a-z0-9][a-z0-9._-]*$/u.test(value))
+        invalid("stable_key_invalid", `${label}:${String(value)}`);
+}
+export function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => compareText(left, right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export function compareScalar(left, right) {
+    if (typeof left !== typeof right)
+        return typeof left === "number" ? -1 : 1;
+    return typeof left === "number"
+        ? left - right
+        : compareText(left, right);
+}
+export function scalarEqual(left, right) {
+    return typeof left === typeof right && left === right;
+}
+export function domainCardinality(domain) {
+    return domain.kind === "enum"
+        ? BigInt(domain.values.length)
+        : BigInt(domain.maximum) - BigInt(domain.minimum) + 1n;
+}
+export function neverValue(value) {
+    return String(value);
+}
+export function invalid(code, detail) {
+    throw new Error(`symbolic_denotation_invalid:${code}:${detail}`);
+}

package/dist/lib/symbolic-denotation-types.d.ts

@@ -0,0 +1,133 @@
+export type SymbolicDenotationScalar = string | number;
+export type SymbolicDenotationAxisDomain = {
+    key: string;
+    kind: "enum";
+    values: string[];
+} | {
+    key: string;
+    kind: "bounded_number";
+    minimum: number;
+    maximum: number;
+    integer: true;
+};
+export type SymbolicDenotationPredicate = {
+    op: "eq";
+    axis_ref: string;
+    value: SymbolicDenotationScalar;
+} | {
+    op: "in";
+    axis_ref: string;
+    values: SymbolicDenotationScalar[];
+} | {
+    op: "range";
+    axis_ref: string;
+    minimum: number;
+    maximum: number;
+    minimum_inclusive: boolean;
+    maximum_inclusive: boolean;
+} | {
+    op: "all" | "any";
+    predicates: SymbolicDenotationPredicate[];
+} | {
+    op: "not";
+    predicate: SymbolicDenotationPredicate;
+};
+export interface SymbolicDenotationComplexityLimits {
+    max_predicate_depth: number;
+    max_input_predicate_nodes: number;
+    max_canonical_dag_nodes: number;
+    max_partition_edges: number;
+    max_canonical_bytes: number;
+}
+export interface SymbolicDenotationCanonicalDagV1 {
+    schema_version: "symbolic-denotation-canonical-dag-v1";
+    root_ref: string;
+    nodes: SymbolicDenotationCanonicalNodeV1[];
+}
+export interface SymbolicDenotationCanonicalNodeV1 {
+    key: string;
+    axis_ref: string;
+    edges: SymbolicDenotationCanonicalEdgeV1[];
+}
+export type SymbolicDenotationCanonicalEdgeV1 = {
+    region: {
+        kind: "enum_set";
+        values: string[];
+    };
+    child_ref: string;
+} | {
+    region: {
+        kind: "integer_range";
+        minimum: number;
+        maximum: number;
+    };
+    child_ref: string;
+};
+export interface CompiledSymbolicDenotationV1 {
+    canonical_dag: SymbolicDenotationCanonicalDagV1;
+    canonical_sha256: string;
+    canonical_bytes: number;
+    referenced_axis_refs: string[];
+    omitted_axis_refs: string[];
+    theoretical_ground_cardinality: string;
+    metrics: {
+        input_predicate_nodes: number;
+        canonical_dag_nodes: number;
+        partition_edges: number;
+        canonical_bytes: number;
+    };
+}
+export declare const SYMBOLIC_DENOTATION_DISPOSITIONS: readonly ["specified", "not_applicable", "excluded", "decision_required", "unavailable", "blocking"];
+export type SymbolicDenotationDisposition = (typeof SYMBOLIC_DENOTATION_DISPOSITIONS)[number];
+export declare const SYMBOLIC_DENOTATION_QUANTIFIERS: readonly ["one", "all", "any", "none", "exactly", "at_least", "at_most", "range"];
+export type SymbolicDenotationQuantifier = (typeof SYMBOLIC_DENOTATION_QUANTIFIERS)[number];
+export interface SymbolicExtensionalPointV1 {
+    subject_or_relation_ref: string;
+    target_ref: string;
+    condition_assignment: Record<string, SymbolicDenotationScalar>;
+    variation_assignment: Record<string, SymbolicDenotationScalar>;
+    property_ref: string;
+    population_ref: string | null;
+    quantifier: {
+        kind: SymbolicDenotationQuantifier;
+        minimum: number | null;
+        maximum: number | null;
+    };
+}
+export interface SymbolicExpectedSemanticsV1 {
+    value_type: string;
+    expected: {
+        locator: {
+            resource_ref: string;
+            kind: string;
+            value: string;
+        };
+        sha256: string;
+    };
+    provenance_ref: string;
+    sensitivity: string;
+    population_ref: string | null;
+    quantifier: SymbolicExtensionalPointV1["quantifier"];
+    lineage: unknown;
+}
+export interface SymbolicProofObligationDenotationV1 {
+    method: string;
+    proof_surface: string;
+    observation_boundary: string;
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: unknown;
+        tolerance: unknown;
+        mask: unknown;
+    };
+    oracle: unknown;
+    environment: unknown;
+    protected_value_policy: string;
+    completion_effect: string;
+}
+export interface SymbolicPointDenotationV1 {
+    disposition: SymbolicDenotationDisposition;
+    expected_semantics: SymbolicExpectedSemanticsV1 | null;
+    proof_obligations: SymbolicProofObligationDenotationV1[];
+}

package/dist/lib/symbolic-denotation-types.js

@@ -0,0 +1,18 @@
+export const SYMBOLIC_DENOTATION_DISPOSITIONS = [
+    "specified",
+    "not_applicable",
+    "excluded",
+    "decision_required",
+    "unavailable",
+    "blocking",
+];
+export const SYMBOLIC_DENOTATION_QUANTIFIERS = [
+    "one",
+    "all",
+    "any",
+    "none",
+    "exactly",
+    "at_least",
+    "at_most",
+    "range",
+];

package/dist/lib/symbolic-denotation-validation.d.ts

@@ -0,0 +1,6 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+export interface SymbolicPredicateInspection {
+    input_nodes: number;
+    number_cuts: Map<string, Set<number>>;
+}
+export declare function validateSymbolicPredicate(input: SymbolicDenotationPredicate, domains: SymbolicDenotationAxisDomain[], domainIndex: ReadonlyMap<string, number>, inspection: SymbolicPredicateInspection, depth: number, limits: SymbolicDenotationComplexityLimits): SymbolicDenotationPredicate;

package/dist/lib/symbolic-denotation-validation.js

@@ -0,0 +1,126 @@
+import { compareScalar, exactKeys, invalid, } from "./symbolic-denotation-support.js";
+export function validateSymbolicPredicate(input, domains, domainIndex, inspection, depth, limits) {
+    inspectPredicateNode(input, depth, inspection, limits);
+    switch (input.op) {
+        case "eq":
+            return validateEq(input, domains, domainIndex, inspection);
+        case "in":
+            return validateIn(input, domains, domainIndex, inspection);
+        case "range":
+            return validateRange(input, domains, domainIndex, inspection);
+        case "all":
+        case "any":
+            return validateGroup(input, domains, domainIndex, inspection, depth, limits);
+        case "not":
+            return validateNot(input, domains, domainIndex, inspection, depth, limits);
+        default:
+            return invalid("predicate_operator_unknown", String(input.op));
+    }
+}
+function inspectPredicateNode(input, depth, inspection, limits) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        invalid("predicate_invalid", "not_object");
+    if (depth > limits.max_predicate_depth)
+        invalid("predicate_depth_limit_exceeded", `actual=${depth}:limit=${limits.max_predicate_depth}`);
+    inspection.input_nodes += 1;
+    if (inspection.input_nodes > limits.max_input_predicate_nodes)
+        invalid("predicate_node_limit_exceeded", `actual=${inspection.input_nodes}:limit=${limits.max_input_predicate_nodes}`);
+}
+function validateEq(input, domains, domainIndex, inspection) {
+    exactKeys(input, ["op", "axis_ref", "value"], "predicate:eq");
+    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
+    validateScalar(domain, input.value);
+    addNumberCuts(domain, [input.value], inspection);
+    return { ...input };
+}
+function validateIn(input, domains, domainIndex, inspection) {
+    exactKeys(input, ["op", "axis_ref", "values"], "predicate:in");
+    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
+    if (!Array.isArray(input.values) || !input.values.length)
+        invalid("predicate_in_values_required", input.axis_ref);
+    const values = input.values.map((value) => {
+        validateScalar(domain, value);
+        return value;
+    });
+    if (new Set(values.map((value) => `${typeof value}:${value}`)).size !==
+        values.length)
+        invalid("predicate_in_value_duplicate", input.axis_ref);
+    addNumberCuts(domain, values, inspection);
+    return { ...input, values: [...values].sort(compareScalar) };
+}
+function validateRange(input, domains, domainIndex, inspection) {
+    exactKeys(input, [
+        "op",
+        "axis_ref",
+        "minimum",
+        "maximum",
+        "minimum_inclusive",
+        "maximum_inclusive",
+    ], "predicate:range");
+    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
+    validateRangeBounds(input, domain);
+    const effectiveMinimum = input.minimum + (input.minimum_inclusive ? 0 : 1);
+    const effectiveMaximum = input.maximum - (input.maximum_inclusive ? 0 : 1);
+    if (effectiveMinimum > effectiveMaximum)
+        invalid("predicate_range_empty", input.axis_ref);
+    addCuts(inspection, domain.key, effectiveMinimum, effectiveMaximum + 1);
+    return { ...input };
+}
+function validateRangeBounds(input, domain) {
+    if (domain.kind !== "bounded_number" ||
+        !Number.isSafeInteger(input.minimum) ||
+        !Number.isSafeInteger(input.maximum) ||
+        typeof input.minimum_inclusive !== "boolean" ||
+        typeof input.maximum_inclusive !== "boolean" ||
+        input.minimum < domain.minimum ||
+        input.maximum > domain.maximum ||
+        input.minimum > input.maximum)
+        invalid("predicate_range_invalid", input.axis_ref);
+}
+function validateGroup(input, domains, domainIndex, inspection, depth, limits) {
+    exactKeys(input, ["op", "predicates"], `predicate:${input.op}`);
+    if (!Array.isArray(input.predicates) || !input.predicates.length)
+        invalid("predicate_children_required", input.op);
+    return {
+        op: input.op,
+        predicates: input.predicates.map((predicate) => validateSymbolicPredicate(predicate, domains, domainIndex, inspection, depth + 1, limits)),
+    };
+}
+function validateNot(input, domains, domainIndex, inspection, depth, limits) {
+    exactKeys(input, ["op", "predicate"], "predicate:not");
+    return {
+        op: "not",
+        predicate: validateSymbolicPredicate(input.predicate, domains, domainIndex, inspection, depth + 1, limits),
+    };
+}
+function predicateDomain(axisRef, domains, domainIndex) {
+    if (typeof axisRef !== "string")
+        invalid("predicate_axis_invalid", "");
+    const index = domainIndex.get(axisRef);
+    if (index === undefined)
+        invalid("predicate_axis_unknown", axisRef);
+    return domains[index];
+}
+function validateScalar(domain, value) {
+    if (domain.kind === "enum") {
+        if (typeof value !== "string" || !domain.values.includes(value))
+            invalid("predicate_value_outside_domain", `${domain.key}:${String(value)}`);
+        return;
+    }
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < domain.minimum ||
+        value > domain.maximum)
+        invalid("predicate_value_outside_domain", `${domain.key}:${String(value)}`);
+}
+function addNumberCuts(domain, values, inspection) {
+    if (domain.kind !== "bounded_number")
+        return;
+    for (const value of values)
+        addCuts(inspection, domain.key, value, value + 1);
+}
+function addCuts(inspection, axisRef, ...cuts) {
+    const values = inspection.number_cuts.get(axisRef) ?? new Set();
+    cuts.forEach((cut) => values.add(cut));
+    inspection.number_cuts.set(axisRef, values);
+}

package/dist/lib/sync-engine.d.ts

@@ -2,6 +2,7 @@ export interface SyncReport {
     changed: string[];
     skipped: string[];
     blocked: string[];
+    notices?: string[];
 }
 export declare function emptySyncReport(): SyncReport;
 export declare function runSync(projectRoot: string): Promise<SyncReport>;

package/dist/lib/sync-engine.js

@@ -7,6 +7,7 @@ import { AGENTS_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_END, GITHUB_WORKFLOW_BLOCK_
 import { packageAssetPath } from "./paths.js";
 import { assertSupportedSchema } from "./schema-guard.js";
 import { installLongTaskHooks, uninstallLongTaskHooks, } from "./long-task-hook-install.js";
+import { syncLongTaskCodexAgentProfile } from "./long-task-codex-agent-profile.js";
 import { enabledManagedSkillNames, isProfileEnabled } from "./profiles.js";
 export function emptySyncReport() {
     return {
@@ -27,7 +28,9 @@ export async function runSync(projectRoot) {
     for (const managedFile of config.managed_files) {
         await syncManagedFile(projectRoot, root, managedFile, report, config);
     }
-    if (isProfileEnabled(config, "long-task")) {
+    const longTaskEnabled = isProfileEnabled(config, "long-task");
+    await syncLongTaskCodexAgentProfile(projectRoot, root, longTaskEnabled, report);
+    if (longTaskEnabled) {
         await installLongTaskHooks(projectRoot, report);
     }
     else {

package/dist/lib/upgrade.js

@@ -42,6 +42,7 @@ export async function runUpgradeReport(projectRoot) {
     for (const skipped of syncReport.skipped.filter((line) => line.includes("customized"))) {
         lines.push(`sync skipped: ${skipped}`);
     }
+    lines.push(...(syncReport.notices ?? []));
     const doctor = await runDoctor(projectRoot);
     lines.push(`doctor warnings=${doctor.warnings.length} errors=${doctor.errors.length}`);
     const blocked = migrationReport.manualRequired.length > 0 ||

package/dist/long-task-hook.js

@@ -1,13 +1,41 @@
 #!/usr/bin/env node
 import { readActiveLongTaskBinding } from "./lib/long-task-state.js";
 import { stopCheckDeliveryTask } from "./lib/long-task-status-v2.js";
+import { LONG_TASK_IMPLEMENTATION_AGENT, selectedAgentType, } from "./lib/long-task-worker-selection.js";
 import { repositoryRoot } from "./lib/long-task-workspace.js";
+const LONG_TASK_IMPLEMENTATION_BOUNDARY = [
+    "This is a delegated rolling implementation worker, not the parent Long-Task Goal.",
+    "Follow only the bounded packet from the parent.",
+    "Do not run long-task resume, Preflight, Compile, Authority Revision, verify as formal Progress, Final Gate, Stop/close, abandon, or completion.",
+    "The parent Goal owns Source, Contract, Authority, Context writeback, integration and formal acceptance.",
+    "Your report is advisory and is not Progress, Evidence or acceptance.",
+].join("\n");
+const AGENT_SPAWN_TOOLS = new Set(["spawn_agent", "Agent"]);
+const EXACT_WORKER_REQUIRED = "Active Tiny Context Long-Task permits delegation only to the exact custom agent long_task_implementation. The current host request does not explicitly select it. Do not substitute a generic worker; complete this packet in the parent Goal.";
 const input = await readStdin();
+const isAgentSpawnPreToolUse = input.hook_event_name === "PreToolUse" &&
+    AGENT_SPAWN_TOOLS.has(input.tool_name ?? "");
+if (input.hook_event_name === "PreToolUse" && !isAgentSpawnPreToolUse)
+    output({});
 try {
     const root = await repositoryRoot(input.cwd || process.cwd());
     const active = await readActiveLongTaskBinding(root);
     if (!active)
         output({});
+    if (isAgentSpawnPreToolUse) {
+        if (selectedAgentType(input.tool_input) === LONG_TASK_IMPLEMENTATION_AGENT)
+            output({});
+        denyAgentSpawn(EXACT_WORKER_REQUIRED);
+    }
+    if (input.hook_event_name === "SubagentStart")
+        output(input.agent_type === LONG_TASK_IMPLEMENTATION_AGENT
+            ? {
+                hookSpecificOutput: {
+                    hookEventName: "SubagentStart",
+                    additionalContext: LONG_TASK_IMPLEMENTATION_BOUNDARY,
+                },
+            }
+            : {});
     if (input.hook_event_name === "SessionStart" ||
         input.hook_event_name === "PostCompact")
         output({
@@ -35,7 +63,9 @@ try {
     });
 }
 catch (error) {
-    const reason = `Long-task Live Final Gate failed closed: ${message(error)}`;
+    const reason = `Tiny Context Long-Task Hook failed closed: ${message(error)}`;
+    if (isAgentSpawnPreToolUse)
+        denyAgentSpawn(`${reason} Do not spawn a substitute agent; complete the packet in the parent Goal.`);
     if (input.hook_event_name === "Stop")
         output({ decision: "block", reason });
     output({ continue: false, stopReason: reason });
@@ -50,6 +80,15 @@ function output(value) {
     process.stdout.write(`${JSON.stringify(value)}\n`);
     process.exit(0);
 }
+function denyAgentSpawn(reason) {
+    output({
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    });
+}
 function message(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/public-types.d.ts

@@ -0,0 +1,8 @@
+export type { HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./lib/types.js";
+export type { CheckExecutionResultV2, CompiledDeliveryContractV2, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, } from "./lib/long-task-delivery-types.js";
+export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, } from "./lib/long-task-boundary-check.js";
+export type { DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, } from "./lib/design-resource-handoff-bundle.js";
+export type { DesignResourceHandoffPreflightV1, DesignResourceHandoffV1, } from "./lib/design-resource-handoff-types.js";
+export type { DesignResourceHandoffPreflightV2, DesignResourceHandoffV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, } from "./lib/design-resource-symbolic-fact-types.js";
+export type { DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, } from "./lib/design-resource-symbolic-source-ir-types.js";
+export type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, } from "./lib/symbolic-denotation-types.js";

package/dist/public-types.js

@@ -0,0 +1 @@
+export {};