project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/design-resource-symbolic-structural-closure-validation.js

@@ -1,79 +0,0 @@
-import { validateDesignResourceLocatedDigest } from "./design-resource-fact-locator-validation.js";
-import { validateSymbolicQuantifier, validateSymbolicRegionWithinReachable, } from "./design-resource-symbolic-region-validation.js";
-import { assertNoUnprovedOmittedAxes } from "./design-resource-symbolic-safety-validation.js";
-import { assertSameSet, invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
-export function validateSymbolicSubjectPopulationClosure(manifest, target, indexes, resources, contents, compilation) {
-    validateSubjects(manifest, target.key, indexes);
-    validatePopulations(manifest, target, indexes, resources, contents, compilation);
-}
-export function validateSymbolicCensusClosure(manifest, indexes) {
-    validateCensusClosure(manifest, indexes);
-}
-function validateSubjects(manifest, targetKey, indexes) {
-    const stableKeys = [];
-    for (const subject of manifest.subjects) {
-        if (!subject.stable_keys.length)
-            invalid("v2_subject_stable_keys_required", subject.key);
-        unique(subject.stable_keys, `v2_subject_stable_key_duplicate:${subject.key}`);
-        stableKeys.push(...subject.stable_keys);
-        assertSameSet(subject.target_refs, [targetKey], "v2_subject_target_mismatch", subject.key);
-        requireKnownRefs(subject.census_refs, indexes.census, "v2_subject_census_unknown");
-        if (subject.population_ref &&
-            !indexes.populations.has(subject.population_ref))
-            invalid("v2_subject_population_unknown", subject.key);
-        for (const ref of [
-            subject.parent_ref,
-            subject.instance_of_ref,
-            subject.override_of_ref,
-            subject.family_ref,
-            subject.portal_host_ref,
-        ])
-            if (ref !== null && !indexes.subjects.has(ref))
-                invalid("v2_subject_hierarchy_ref_unknown", `${subject.key}:${ref}`);
-        unique(subject.relation_endpoints.map((item) => item.role), `v2_relation_endpoint_role_duplicate:${subject.key}`);
-        for (const endpoint of subject.relation_endpoints)
-            if (!indexes.subjects.has(endpoint.subject_ref))
-                invalid("v2_relation_endpoint_subject_unknown", `${subject.key}:${endpoint.subject_ref}`);
-        if (subject.kind === "relation" && subject.relation_endpoints.length < 2)
-            invalid("v2_relation_endpoints_incomplete", subject.key);
-        if (subject.presence === "always" && subject.presence_rule_ref !== null)
-            invalid("v2_subject_always_presence_rule_forbidden", subject.key);
-    }
-    unique(stableKeys, "v2_subject_stable_key_ambiguous");
-}
-function validatePopulations(manifest, target, indexes, resources, contents, compilation) {
-    const targetResources = new Set(target.resource_refs);
-    for (const population of manifest.populations) {
-        requireKnownRefs(population.member_subject_refs, indexes.subjects, "v2_population_subject_unknown");
-        assertSameSet(population.member_subject_refs, manifest.subjects
-            .filter((subject) => subject.population_ref === population.key)
-            .map((subject) => subject.key), "v2_population_member_set_mismatch", population.key);
-        if ((population.kind === "static" && population.enumeration !== "complete") ||
-            (population.kind === "dynamic" &&
-                population.enumeration !== "symbolic_partition"))
-            invalid("v2_population_enumeration_mismatch", population.key);
-        validateDesignResourceLocatedDigest(population.universe, resources, contents, `v2.population.${population.key}.universe`);
-        if (!targetResources.has(population.universe.locator.resource_ref))
-            invalid("v2_population_resource_outside_target", population.key);
-        validateSymbolicQuantifier(population.quantifier, population.key);
-        unique(population.exclusions.map((item) => item.key), `v2_population_exclusion_key_duplicate:${population.key}`);
-        for (const exclusion of population.exclusions) {
-            if (!exclusion.basis_refs.length)
-                invalid("v2_population_exclusion_basis_required", exclusion.key);
-            const compiled = compilation.compile(exclusion.region);
-            assertNoUnprovedOmittedAxes(compiled, exclusion.key);
-            validateSymbolicRegionWithinReachable(exclusion.region, manifest.reachable_region, exclusion.key, compilation);
-        }
-    }
-}
-function validateCensusClosure(manifest, indexes) {
-    const rules = new Map(manifest.fact_rules.map((item) => [item.key, item]));
-    for (const row of manifest.inspector.census) {
-        requireKnownRefs(row.fact_refs, rules, "v2_census_rule_unknown");
-        requireKnownRefs(row.source_item_refs, indexes.sourceItems, "v2_census_source_item_unknown");
-        if (!row.source_item_refs.length || !row.basis_refs.length)
-            invalid("v2_census_basis_source_required", row.key);
-        unique(row.fact_refs, `v2_census_rule_ref_duplicate:${row.key}`);
-        assertSameSet(row.fact_refs, (indexes.rulesByCensus.get(row.key) ?? []).map((rule) => rule.key), "v2_census_rule_set_mismatch", row.key);
-    }
-}

package/dist/lib/design-resource-symbolic-validation-support.d.ts

@@ -1,29 +0,0 @@
-import type { DesignResourceObservableRuleManifestV2, DesignResourceSymbolicDependencyEdgeV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-fact-types.js";
-export declare function designResourceSymbolicRuleKey(rule: Omit<DesignResourceSymbolicFactRuleV2, "key" | "semantic_obligation_refs">, regionSha256: string): string;
-export declare function designResourceSymbolicObligationKey(obligation: Omit<DesignResourceObservableRuleManifestV2["semantic_proof_obligations"][number], "key">): string;
-export declare function designResourceSymbolicDependencyEdge(axisRef: string, factRuleRef: string): DesignResourceSymbolicDependencyEdgeV2;
-export declare function designResourceSymbolicCertificateKey(certificate: Omit<DesignResourceSymbolicNoninterferenceCertificateV2, "key">): string;
-export declare function designResourceSymbolicNoninterferenceProofDigest(proof: DesignResourceSymbolicNoninterferenceCertificateV2["source_noninterference_proof"]): string | null;
-export declare function designResourceSymbolicCombinedRuleDigest(ruleProjections: Array<{
-    rule: {
-        key: string;
-    };
-    compiled_region: {
-        canonical_sha256: string;
-    };
-}>): string;
-export declare function omitRuleIdentityFields(rule: DesignResourceSymbolicFactRuleV2): Omit<DesignResourceSymbolicFactRuleV2, "key" | "semantic_obligation_refs">;
-export declare function omitKey<T extends {
-    key: string;
-}>(value: T): Omit<T, "key">;
-export declare function requireExactRefs<T>(refs: string[], values: Map<string, T>, code: string): void;
-export declare function requireKnownRefs(refs: string[], values: ReadonlyMap<string, unknown> | ReadonlySet<string>, code: string): void;
-export declare function unique(values: string[], code: string): void;
-export declare function assertSameSet(actual: string[], expected: string[], code: string, detail: string): void;
-export declare function assertCanonicalSet<T extends {
-    key: string;
-}>(actual: T[], expected: T[], code: string): void;
-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 invalid(code: string, detail: string): never;

package/dist/lib/design-resource-symbolic-validation-support.js

@@ -1,111 +0,0 @@
-import { createHash } from "node:crypto";
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-const ALL_EFFECTS = [
-    "disposition",
-    "expected_semantics",
-    "proof_denotation",
-];
-export function designResourceSymbolicRuleKey(rule, regionSha256) {
-    return `rule.${sha256(stableJson({
-        subject_or_relation_ref: rule.subject_or_relation_ref,
-        target_ref: rule.target_ref,
-        property_ref: rule.property_ref,
-        population_ref: rule.population_ref,
-        quantifier: rule.quantifier,
-        region_sha256: regionSha256,
-        expected: rule.expected,
-        value_kind: rule.value_kind,
-        provenance_ref: rule.provenance_ref,
-        observation_scope: rule.observation_scope,
-        observation_sensitivity: rule.observation_sensitivity,
-        lineage: rule.lineage,
-        evidence_refs: [...rule.evidence_refs].sort(compareText),
-        census_refs: [...rule.census_refs].sort(compareText),
-        source_item_refs: [...rule.source_item_refs].sort(compareText),
-    }))}`;
-}
-export function designResourceSymbolicObligationKey(obligation) {
-    return `obligation.${sha256(stableJson(obligation))}`;
-}
-export function designResourceSymbolicDependencyEdge(axisRef, factRuleRef) {
-    const body = {
-        axis_ref: axisRef,
-        fact_rule_ref: factRuleRef,
-        effects: [...ALL_EFFECTS],
-    };
-    return { key: `edge.${sha256(stableJson(body))}`, ...body };
-}
-export function designResourceSymbolicCertificateKey(certificate) {
-    return `certificate.${sha256(stableJson({
-        ...certificate,
-        fact_rule_refs: [...certificate.fact_rule_refs].sort(compareText),
-        omitted_axis_refs: [...certificate.omitted_axis_refs].sort(compareText),
-        dependency_edge_refs: [...certificate.dependency_edge_refs].sort(compareText),
-    }))}`;
-}
-export function designResourceSymbolicNoninterferenceProofDigest(proof) {
-    return proof ? sha256(stableJson(proof)) : null;
-}
-export function designResourceSymbolicCombinedRuleDigest(ruleProjections) {
-    return sha256(stableJson(ruleProjections
-        .map((projection) => ({
-        rule_ref: projection.rule.key,
-        region_sha256: projection.compiled_region.canonical_sha256,
-    }))
-        .sort((left, right) => compareText(left.rule_ref, right.rule_ref))));
-}
-export function omitRuleIdentityFields(rule) {
-    const { key: _key, semantic_obligation_refs: _refs, ...value } = rule;
-    return value;
-}
-export function omitKey(value) {
-    const { key: _key, ...rest } = value;
-    return rest;
-}
-export function requireExactRefs(refs, values, code) {
-    unique(refs, `${code}_duplicate`);
-    requireKnownRefs(refs, values, `${code}_unknown`);
-}
-export function requireKnownRefs(refs, values, code) {
-    for (const ref of refs)
-        if (!values.has(ref))
-            invalid(code, ref);
-}
-export function unique(values, code) {
-    if (new Set(values).size !== values.length)
-        invalid(code, "");
-}
-export function assertSameSet(actual, expected, code, detail) {
-    const left = [...new Set(actual)].sort(compareText);
-    const right = [...new Set(expected)].sort(compareText);
-    if (left.length !== right.length ||
-        left.some((item, index) => item !== right[index]))
-        invalid(code, `${detail}:${left.join(",")}:${right.join(",")}`);
-}
-export function assertCanonicalSet(actual, expected, code) {
-    const left = new Map(actual.map((item) => [item.key, stableJson(item)]));
-    const right = new Map(expected.map((item) => [item.key, stableJson(item)]));
-    assertSameSet([...left.keys()], [...right.keys()], code, "keys");
-    for (const [key, value] of right)
-        if (left.get(key) !== value)
-            invalid(code, key);
-}
-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 invalid(code, detail) {
-    invalidDesignResourceHandoff(code, detail);
-}

package/dist/lib/design-resource-v1-capacity-header.d.ts

@@ -1,8 +0,0 @@
-declare const V1_SCHEMA = "design-resource-observable-fact-manifest-v1";
-export declare const DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE = "regenerate_as=design-resource-handoff-v2:fact_model=symbolic_rules_v2";
-export interface DesignResourceV1CapacityHeader {
-    schema_version: typeof V1_SCHEMA;
-    collection_counts: ReadonlyMap<string, number>;
-}
-export declare function parseDesignResourceV1CapacityHeader(prefix: string): DesignResourceV1CapacityHeader;
-export {};

package/dist/lib/design-resource-v1-capacity-header.js

@@ -1,231 +0,0 @@
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-import { DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY } from "./design-resource-symbolic-fact-policy.js";
-const V1_SCHEMA = "design-resource-observable-fact-manifest-v1";
-export const DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE = "regenerate_as=design-resource-handoff-v2:fact_model=symbolic_rules_v2";
-export function parseDesignResourceV1CapacityHeader(prefix) {
-    try {
-        const reader = new BoundedJsonReader(prefix);
-        const header = reader.readRootHeader();
-        if (header.first_key !== "schema_version")
-            invalid("v1_manifest_capacity_header_order_invalid", `first_key=${header.first_key ?? "missing"}:required=schema_version`);
-        if (header.schema_version !== V1_SCHEMA)
-            invalid("v1_manifest_capacity_header_schema_invalid", `schema_version=${String(header.schema_version)}`);
-        if (!header.generation)
-            invalid("v1_manifest_capacity_header_missing_or_late", `prefix_limit=${DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity.capacity_header_prefix_max_bytes}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
-        const collections = objectValue(header.generation, "v1_manifest_capacity_header_generation_invalid").collections;
-        if (!Array.isArray(collections))
-            invalid("v1_manifest_capacity_header_collections_invalid", "not_array");
-        const collectionCounts = new Map();
-        for (const value of collections) {
-            const collection = objectValue(value, "v1_manifest_capacity_header_collection_invalid");
-            if (typeof collection.name !== "string" || !collection.name)
-                invalid("v1_manifest_capacity_header_collection_name_invalid", "");
-            if (typeof collection.expected_count !== "number" ||
-                !Number.isSafeInteger(collection.expected_count) ||
-                collection.expected_count < 0)
-                invalid("v1_manifest_capacity_header_expected_count_invalid", collection.name);
-            if (collectionCounts.has(collection.name))
-                invalid("v1_manifest_capacity_header_collection_duplicate", collection.name);
-            collectionCounts.set(collection.name, collection.expected_count);
-        }
-        return {
-            schema_version: V1_SCHEMA,
-            collection_counts: collectionCounts,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message.startsWith("design_resource_handoff_invalid:"))
-            throw error;
-        const message = error instanceof Error ? error.message : String(error);
-        invalid("v1_manifest_capacity_header_missing_or_late", `prefix_limit=${DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity.capacity_header_prefix_max_bytes}:reason=${message}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
-    }
-}
-class BoundedJsonReader {
-    input;
-    offset = 0;
-    depth = 0;
-    constructor(input) {
-        this.input = input;
-    }
-    readRootHeader() {
-        this.whitespace();
-        this.character("{");
-        const result = {
-            first_key: null,
-            schema_version: undefined,
-            generation: undefined,
-        };
-        this.whitespace();
-        if (this.peek() === "}")
-            throw new Error("root_empty");
-        for (;;) {
-            const key = this.string();
-            result.first_key ??= key;
-            this.whitespace();
-            this.character(":");
-            this.whitespace();
-            const value = this.value();
-            if (key === "schema_version")
-                result.schema_version = value;
-            if (key === "generation") {
-                result.generation = value;
-                return result;
-            }
-            this.whitespace();
-            const delimiter = this.peek();
-            if (delimiter === "}")
-                return result;
-            this.character(",");
-            this.whitespace();
-        }
-    }
-    value() {
-        if (++this.depth > 64)
-            throw new Error("depth_limit");
-        try {
-            const next = this.peek();
-            if (next === '"')
-                return this.string();
-            if (next === "{")
-                return this.object();
-            if (next === "[")
-                return this.array();
-            if (next === "t")
-                return this.literal("true", true);
-            if (next === "f")
-                return this.literal("false", false);
-            if (next === "n")
-                return this.literal("null", null);
-            return this.number();
-        }
-        finally {
-            this.depth -= 1;
-        }
-    }
-    object() {
-        const value = {};
-        this.character("{");
-        this.whitespace();
-        if (this.peek() === "}") {
-            this.offset += 1;
-            return value;
-        }
-        for (;;) {
-            const key = this.string();
-            if (Object.hasOwn(value, key))
-                throw new Error(`duplicate_key:${key}`);
-            this.whitespace();
-            this.character(":");
-            this.whitespace();
-            value[key] = this.value();
-            this.whitespace();
-            if (this.peek() === "}") {
-                this.offset += 1;
-                return value;
-            }
-            this.character(",");
-            this.whitespace();
-        }
-    }
-    array() {
-        const value = [];
-        this.character("[");
-        this.whitespace();
-        if (this.peek() === "]") {
-            this.offset += 1;
-            return value;
-        }
-        for (;;) {
-            value.push(this.value());
-            this.whitespace();
-            if (this.peek() === "]") {
-                this.offset += 1;
-                return value;
-            }
-            this.character(",");
-            this.whitespace();
-        }
-    }
-    string() {
-        this.character('"');
-        let value = "";
-        for (;;) {
-            if (this.offset >= this.input.length)
-                throw new Error("prefix_ended");
-            const character = this.input[this.offset++];
-            if (character === '"')
-                return value;
-            if (character === "\\") {
-                if (this.offset >= this.input.length)
-                    throw new Error("prefix_ended");
-                const escaped = this.input[this.offset++];
-                const simple = {
-                    '"': '"',
-                    "\\": "\\",
-                    "/": "/",
-                    b: "\b",
-                    f: "\f",
-                    n: "\n",
-                    r: "\r",
-                    t: "\t",
-                };
-                if (escaped in simple)
-                    value += simple[escaped];
-                else if (escaped === "u") {
-                    const hex = this.input.slice(this.offset, this.offset + 4);
-                    if (!/^[0-9a-fA-F]{4}$/u.test(hex))
-                        throw new Error("unicode_escape_invalid");
-                    value += String.fromCharCode(Number.parseInt(hex, 16));
-                    this.offset += 4;
-                }
-                else
-                    throw new Error("escape_invalid");
-            }
-            else {
-                if (character.charCodeAt(0) < 0x20)
-                    throw new Error("string_control_character");
-                value += character;
-            }
-        }
-    }
-    number() {
-        const remaining = this.input.slice(this.offset);
-        const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(remaining);
-        if (!match)
-            throw new Error("number_invalid");
-        this.offset += match[0].length;
-        const value = Number(match[0]);
-        if (!Number.isFinite(value))
-            throw new Error("number_non_finite");
-        return value;
-    }
-    literal(token, value) {
-        if (this.input.slice(this.offset, this.offset + token.length) !== token)
-            throw new Error(`literal_invalid:${token}`);
-        this.offset += token.length;
-        return value;
-    }
-    whitespace() {
-        while (/\s/u.test(this.input[this.offset] ?? ""))
-            this.offset += 1;
-    }
-    character(expected) {
-        if (this.input[this.offset] !== expected)
-            throw new Error(`expected:${expected}:at=${this.offset}`);
-        this.offset += 1;
-    }
-    peek() {
-        if (this.offset >= this.input.length)
-            throw new Error("prefix_ended");
-        return this.input[this.offset];
-    }
-}
-function objectValue(value, code) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        invalid(code, "not_object");
-    return value;
-}
-function invalid(code, detail) {
-    invalidDesignResourceHandoff(code, detail);
-}

package/dist/lib/design-resource-v1-capacity.d.ts

@@ -1,5 +0,0 @@
-import { type DesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
-export { parseDesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
-export type { DesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
-export declare function assertDesignResourceV1HandoffCapacity(file: string): Promise<void>;
-export declare function assertDesignResourceV1ManifestCapacity(file: string): Promise<DesignResourceV1CapacityHeader>;

package/dist/lib/design-resource-v1-capacity.js

@@ -1,45 +0,0 @@
-import { open, stat } from "node:fs/promises";
-import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-import { DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY } from "./design-resource-symbolic-fact-policy.js";
-import { DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE, parseDesignResourceV1CapacityHeader, } from "./design-resource-v1-capacity-header.js";
-export { parseDesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
-export async function assertDesignResourceV1HandoffCapacity(file) {
-    const bytes = (await stat(file)).size;
-    const limit = DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity.embedded_handoff_max_bytes;
-    if (bytes > limit)
-        invalid("v1_handoff_capacity_exceeded", `bytes=${bytes}:limit=${limit}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
-}
-export async function assertDesignResourceV1ManifestCapacity(file) {
-    const bytes = (await stat(file)).size;
-    const policy = DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity;
-    if (bytes > policy.canonical_manifest_max_bytes)
-        invalid("v1_manifest_capacity_exceeded", `bytes=${bytes}:limit=${policy.canonical_manifest_max_bytes}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
-    const prefixBytes = Math.min(bytes, policy.capacity_header_prefix_max_bytes);
-    const buffer = Buffer.alloc(prefixBytes);
-    const handle = await open(file, "r");
-    try {
-        let offset = 0;
-        while (offset < prefixBytes) {
-            const result = await handle.read(buffer, offset, prefixBytes - offset, offset);
-            if (result.bytesRead === 0)
-                break;
-            offset += result.bytesRead;
-        }
-        if (offset !== prefixBytes)
-            invalid("v1_manifest_capacity_header_read_incomplete", `bytes_read=${offset}:expected=${prefixBytes}`);
-    }
-    finally {
-        await handle.close();
-    }
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
-    const header = parseDesignResourceV1CapacityHeader(text);
-    const expectedFactCells = header.collection_counts.get("fact_cells");
-    if (expectedFactCells === undefined)
-        invalid("v1_manifest_capacity_header_fact_cells_missing", DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE);
-    if (expectedFactCells > policy.expected_fact_cells_max)
-        invalid("v1_fact_cell_capacity_exceeded", `expected_count=${expectedFactCells}:limit=${policy.expected_fact_cells_max}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
-    return header;
-}
-function invalid(code, detail) {
-    invalidDesignResourceHandoff(code, detail);
-}

package/dist/lib/execution-target-capabilities.d.ts

@@ -1,2 +0,0 @@
-export declare const EXECUTION_TARGET_CAPABILITIES: readonly ["browser-runtime", "native-runtime", "desktop-runtime", "service-runtime", "process-runtime", "external-runtime", "cold-start", "production-root", "pointer-input", "keyboard-input", "touch-input", "viewport-control", "pixel-density-observation", "safe-area-observation", "motion-observation", "reduced-motion", "color-scheme-control", "text-scale-control", "localization-control", "rtl-control", "assistive-technology", "screen-reader", "physical-device", "device-orientation", "sensor-input", "camera-input", "haptic-output", "audio-output", "reduced-transparency", "increased-contrast", "bold-text-control", "button-shapes-control", "system-ui-observation", "ime-control", "permission-control", "network-state-control", "lifecycle-control", "window-state-control", "fold-state-control", "thermal-observation", "power-mode-control", "persistent-storage", "network-boundary"];
-export type ExecutionTargetCapabilityV2 = (typeof EXECUTION_TARGET_CAPABILITIES)[number];

package/dist/lib/execution-target-capabilities.js

@@ -1,45 +0,0 @@
-export const EXECUTION_TARGET_CAPABILITIES = [
-    "browser-runtime",
-    "native-runtime",
-    "desktop-runtime",
-    "service-runtime",
-    "process-runtime",
-    "external-runtime",
-    "cold-start",
-    "production-root",
-    "pointer-input",
-    "keyboard-input",
-    "touch-input",
-    "viewport-control",
-    "pixel-density-observation",
-    "safe-area-observation",
-    "motion-observation",
-    "reduced-motion",
-    "color-scheme-control",
-    "text-scale-control",
-    "localization-control",
-    "rtl-control",
-    "assistive-technology",
-    "screen-reader",
-    "physical-device",
-    "device-orientation",
-    "sensor-input",
-    "camera-input",
-    "haptic-output",
-    "audio-output",
-    "reduced-transparency",
-    "increased-contrast",
-    "bold-text-control",
-    "button-shapes-control",
-    "system-ui-observation",
-    "ime-control",
-    "permission-control",
-    "network-state-control",
-    "lifecycle-control",
-    "window-state-control",
-    "fold-state-control",
-    "thermal-observation",
-    "power-mode-control",
-    "persistent-storage",
-    "network-boundary",
-];

package/dist/lib/legacy-managed-scan.d.ts

@@ -1,2 +0,0 @@
-import type { Migration, UpgradePlanItem } from "./migrations.js";
-export declare function detectLegacyManagedDirectory(projectRoot: string, root: string, migration: Migration): Promise<UpgradePlanItem[]>;

package/dist/lib/legacy-managed-scan.js

@@ -1,95 +0,0 @@
-import path from "node:path";
-import { listFiles, pathExists, readText } from "./fs.js";
-import { packageAssetPath } from "./paths.js";
-const LEGACY_MANAGED_ROOT = "pjsdlc_managed";
-const CURRENT_MANAGED_ROOT = "ty-context-managed";
-const LEGACY_MAKEFILE = "sdlc-harness.mk";
-const CURRENT_MAKEFILE = "ty-context.mk";
-export async function detectLegacyManagedDirectory(projectRoot, root, migration) {
-    const legacyRoot = path.join(projectRoot, root, LEGACY_MANAGED_ROOT);
-    const files = await listFiles(legacyRoot);
-    const items = [];
-    for (const file of files) {
-        if (path.basename(file) === ".gitkeep") {
-            continue;
-        }
-        const relativeToLegacyRoot = path
-            .relative(legacyRoot, file)
-            .split(path.sep)
-            .join("/");
-        const relativeToProject = path
-            .relative(projectRoot, file)
-            .split(path.sep)
-            .join("/");
-        const classification = await classifyLegacyManagedFile(relativeToLegacyRoot);
-        if (classification.kind === "override") {
-            items.push(item(migration, "manual_required", relativeToProject, "Legacy skill overrides are no longer supported; move rules into a standalone project-local Skill."));
-            continue;
-        }
-        if (classification.kind === "unknown") {
-            items.push(item(migration, "manual_required", relativeToProject, "Legacy pjsdlc_managed content is not recognized as package-generated; review it manually."));
-            continue;
-        }
-        const target = path.join(projectRoot, root, CURRENT_MANAGED_ROOT, ...classification.targetRelative.split("/"));
-        if (!(await pathExists(target))) {
-            continue;
-        }
-        const assetContent = await readText(classification.assetPath);
-        if ((await readText(target)) !== assetContent) {
-            items.push(item(migration, "blocked", path.relative(projectRoot, target).split(path.sep).join("/"), `Cannot refresh legacy generated file because ${classification.targetRelative} already exists with non-package content.`));
-        }
-    }
-    return items;
-}
-async function classifyLegacyManagedFile(relative) {
-    if (relative.startsWith("override_skills/")) {
-        return { kind: "override" };
-    }
-    const mapped = legacyGeneratedMapping(relative);
-    if (!mapped) {
-        return { kind: "unknown" };
-    }
-    const assetPath = packageAssetPath(...mapped.assetSegments);
-    if (!(await pathExists(assetPath))) {
-        return { kind: "unknown" };
-    }
-    return {
-        kind: "generated",
-        targetRelative: mapped.targetRelative,
-        assetPath,
-    };
-}
-function legacyGeneratedMapping(relative) {
-    if (relative === `make/${LEGACY_MAKEFILE}`) {
-        return {
-            targetRelative: `make/${CURRENT_MAKEFILE}`,
-            assetSegments: ["make", CURRENT_MAKEFILE],
-        };
-    }
-    for (const [prefix, assetPrefix] of [
-        ["agents/", "agents"],
-        ["context_templates/", "context_templates"],
-        ["skills/", "skills"],
-        ["minimal_tools/", "tools"],
-    ]) {
-        if (relative.startsWith(prefix)) {
-            const rest = relative.slice(prefix.length);
-            return {
-                targetRelative: `${prefix}${rest}`,
-                assetSegments: [assetPrefix, ...rest.split("/")],
-            };
-        }
-    }
-    return undefined;
-}
-function item(migration, status, pathLabel, message) {
-    return {
-        id: migration.id,
-        introducedIn: migration.introducedIn,
-        description: migration.description,
-        scope: migration.scope,
-        status,
-        path: pathLabel,
-        message,
-    };
-}

package/dist/lib/legacy-sdlc-migration.d.ts

@@ -1,2 +0,0 @@
-import type { Migration } from "./migrations.js";
-export declare const legacySdlcHarnessMigration: Migration;