project-tiny-context-harness 0.7.8 → 0.8.0

package/dist/commands/design-resource.d.ts

@@ -0,0 +1 @@
+export declare function designResource(args: string[]): Promise<void>;

package/dist/commands/design-resource.js

@@ -0,0 +1,32 @@
+import { preflightDesignResourceHandoff } from "../lib/design-resource-handoff-validation.js";
+import { normalizeRepositoryFile } from "../lib/long-task-paths.js";
+import { canonicalJson } from "../lib/strict-codec.js";
+export async function designResource(args) {
+    const [subcommand = "help", ...rest] = args;
+    if (subcommand === "help") {
+        help();
+        return;
+    }
+    if (subcommand !== "preflight")
+        throw new Error(`Unknown design-resource subcommand: ${subcommand}`);
+    const json = rest.includes("--json");
+    const positional = rest.filter((item) => item !== "--json");
+    if (positional.length !== 1)
+        throw new Error("usage: ty-context design-resource preflight <handoff.md> [--json]");
+    const handoffPath = normalizeRepositoryFile(positional[0], "design_resource_handoff");
+    const result = await preflightDesignResourceHandoff(process.cwd(), handoffPath);
+    if (json) {
+        process.stdout.write(canonicalJson(result));
+        return;
+    }
+    console.log(`Design resource handoff ready: ${result.handoff_path}`);
+    console.log(`Scope: ${result.handoff.scope.key}`);
+    console.log(`Targets: ${result.handoff.targets.map((item) => item.key).join(", ")}`);
+    console.log(`Coverage: ${result.counts.subjects} subjects x 8 dimensions (${result.counts.coverage} grouped rows)`);
+    console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
+}
+function help() {
+    console.log(`ty-context design-resource commands:
+  preflight <handoff.md> [--json]
+                       Validate one selected implementation handoff`);
+}

package/dist/commands/index.js

@@ -3,6 +3,7 @@ import { compositeLongTask } from "./composite-long-task.js";
 import { compositeCampaign } from "./composite-campaign.js";
 import { longTask } from "./long-task.js";
 import { deliverySet } from "./delivery-set.js";
+import { designResource } from "./design-resource.js";
 import { doctor } from "./doctor.js";
 import { exportContext } from "./export-context.js";
 import { enable } from "./enable.js";
@@ -28,6 +29,7 @@ export const commands = {
     "validate-code-modularity": (args) => validate(["validate-code-modularity", ...args]),
     "validate-harness": (args) => validate(["validate-harness", ...args]),
     "long-task": (args) => withLongTaskProfile(args, longTask),
+    "design-resource": designResource,
     "delivery-set": deliverySet,
     "composite-long-task": compositeLongTask,
     "composite-campaign": compositeCampaign,
@@ -52,6 +54,8 @@ export function help() {
   validate-code-modularity
                        Enforce touched handwritten source file modularity
   validate-harness     Run validate-context and validate-code-modularity
+  design-resource <subcommand>
+                       Validate a selected design-resource implementation handoff
   long-task <subcommand>
                        Manage one Canonical Delivery Contract in the current workspace
   delivery-set <subcommand>

package/dist/commands/long-task-command-args.d.ts

@@ -1,3 +1,4 @@
 export declare function option(args: string[], name: string): string | undefined;
+export declare function flag(args: string[], name: string): boolean;
 export declare function rejectOptions(args: string[], allowed: string[]): void;
 export declare function rejectUnknown(actual: string[], allowed: string[]): void;

package/dist/commands/long-task-command-args.js

@@ -9,6 +9,12 @@ export function option(args, name) {
         throw new Error(`${name} requires a value`);
     return value;
 }
+export function flag(args, name) {
+    const count = args.filter((value) => value === name).length;
+    if (count > 1)
+        throw new Error(`duplicate option: ${name}`);
+    return count === 1;
+}
 export function rejectOptions(args, allowed) {
     for (let index = 0; index < args.length; index += 2)
         if (!allowed.includes(args[index]) || !args[index + 1])

package/dist/commands/long-task-revision.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { diagnoseAuthorityRevision } from "../lib/long-task-authority-revision-diagnosis.js";
+import { authorityRevisionDecisionNextAction } from "../lib/long-task-authority-revision-brief.js";
 import { projectAuthorityRevisionDecision } from "../lib/long-task-authority-revision-summary.js";
 import { canRetainProgressForSupportingContextRevision } from "../lib/long-task-context-authority.js";
 import { compileDeliveryContract } from "../lib/long-task-delivery-compiler.js";
@@ -89,7 +90,7 @@ function printCompileResult(compiled, previous, preserveProgress, revisionPropos
             ? projectAuthorityRevisionDecision(revisionProposal)
             : null,
         next_action: firstAuthorityLock
-            ? "Complete the one-time model choice, then begin rolling implementation."
+            ? "End this turn now and ask the user to choose continue_current_model or switch_model_then_resume. Do not implement, edit files, build, or test until an explicit task-specific model strategy is received; generic continue or resume language does not satisfy this checkpoint."
             : authorityChanged
                 ? "Run status or resume, then continue rolling implementation or repair under the adopted Authority Revision."
                 : "Continue rolling implementation or repair under the active Authority.",
@@ -116,14 +117,15 @@ async function printPendingDecision(workdir, previous) {
     const pending = await readPendingAuthorityRevision(workdir);
     if (!pending)
         throw new Error("authority_revision_pending_state_missing");
+    const decision = projectAuthorityRevisionDecision(pending);
     console.log(JSON.stringify({
         status: "authority_revision_pending",
         acceptance_authorized: false,
         delivery_completed_by_this_event: false,
         native_goal_effect: "none",
         active_compiled_identity: previous?.compiled_identity ?? null,
-        pending_authority_revision: projectAuthorityRevisionDecision(pending),
-        next_action: "Ask the user to approve or reject this exact material revision; keep the previous Authority active.",
+        pending_authority_revision: decision,
+        next_action: authorityRevisionDecisionNextAction(decision),
     }));
 }
 async function diagnoseRevision(workdir, args) {
@@ -156,7 +158,17 @@ function executionModelCheckpoint(firstAuthorityLock) {
         required: true,
         phase: "post_authority_lock_pre_implementation",
         options: ["continue_current_model", "switch_model_then_resume"],
-        message: "Authority Lock created. Pause before implementation and ask the user whether to continue with the current model or switch models, then resume this active Long-Task.",
+        turn_boundary: "end_current_turn",
+        blocked_until_explicit_choice: [
+            "product_implementation",
+            "file_edits",
+            "build",
+            "test_execution",
+        ],
+        explicit_task_specific_choice_required: true,
+        prior_explicit_task_specific_choice_satisfies: true,
+        generic_continue_satisfies: false,
+        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. Ask the user to explicitly choose continue_current_model or switch_model_then_resume. Generic continue, resume, finish, or continue-goal language does not satisfy this checkpoint.",
     };
 }
 function message(error) {

package/dist/commands/long-task.js

@@ -5,9 +5,10 @@ import { abandonLongTaskState, forceClearCorruptActiveState, } from "../lib/long
 import { verifyDeliveryContract } from "../lib/long-task-verifier-v2.js";
 import { repositoryRoot } from "../lib/long-task-workspace.js";
 import { initializeLongTask, preflightLongTask, } from "./long-task-authoring.js";
-import { option, rejectOptions, rejectUnknown, } from "./long-task-command-args.js";
+import { flag, option, rejectOptions, rejectUnknown, } from "./long-task-command-args.js";
 import { explainLongTask } from "./long-task-explain.js";
 import { handleLongTaskRevisionCommand } from "./long-task-revision.js";
+import { previewVerificationExecution } from "../lib/long-task-verification-preview.js";
 export async function longTask(args) {
     const subcommand = args[0] ?? "help";
     if (subcommand === "help")
@@ -96,9 +97,15 @@ export async function longTask(args) {
     throw new Error(`Unknown long-task subcommand: ${subcommand}`);
 }
 async function verify(workdir, args) {
-    const outcome = option(args, "--outcome");
-    const check = option(args, "--check");
-    rejectOptions(args, ["--outcome", "--check"]);
+    const explain = flag(args, "--explain");
+    const optionArgs = args.filter((value) => value !== "--explain");
+    const outcome = option(optionArgs, "--outcome");
+    const check = option(optionArgs, "--check");
+    rejectOptions(optionArgs, ["--outcome", "--check"]);
+    if (explain) {
+        console.log(JSON.stringify(await previewVerificationExecution(workdir, { outcome, check })));
+        return;
+    }
     const result = await verifyDeliveryContract(workdir, { outcome, check });
     console.log(JSON.stringify(result));
     if (result.findings.length)
@@ -125,7 +132,7 @@ function help() {
   diagnose-revision <workdir> [--outcome <key>] [--check <key>]
   approve-authority-revision <workdir> --revision <sha>
   explain <workdir>
-  verify <workdir> [--outcome <key>] [--check <key>]
+  verify <workdir> [--outcome <key>] [--check <key>] [--explain]
   status <workdir>
   resume <workdir>
   doctor <workdir>

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { commands } from "./commands/index.js";
 export { compileDeliveryContract, type CompileDeliveryOptionsV2, } from "./lib/long-task-delivery-compiler.js";
 export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
 export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
+export { preflightDesignResourceHandoff } from "./lib/design-resource-handoff-validation.js";
 export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
 export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
 export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";

package/dist/index.js

@@ -2,6 +2,7 @@ export { commands } from "./commands/index.js";
 export { compileDeliveryContract, } from "./lib/long-task-delivery-compiler.js";
 export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
 export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
+export { preflightDesignResourceHandoff } from "./lib/design-resource-handoff-validation.js";
 export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
 export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
 export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";

package/dist/lib/design-md.js

@@ -125,7 +125,8 @@ function designMdTemplate() {
         "- Authored exact-value token source: not selected.",
         "- Generation direction and generated token targets: not selected.",
         "- Durable design references: none selected.",
-        "- For each selected reference, record a stable id, surface/route/component, project path or URI, `exact-target` / `constraint` / `inspiration` interpretation, and the viewport/theme/state conditions it covers.",
+        "- For each selected reference, record a stable id, surface/route/component, `exact-target` / `constraint` / `inspiration` interpretation, viewport/theme/state coverage, a readable immutable adopted path/URI plus digest, and the editable upstream owner/locator/update route (or an explicit manual/external-update boundary).",
+        "- Relevant product/design/development work must open affected selected exact targets/constraints; an index entry alone is not resource consumption.",
         "",
         "## Colors",
         "",
@@ -161,6 +162,7 @@ function designMdTemplate() {
         "- When there is a scan target such as UI source, page files, build output or a local/remote URL, run `npx impeccable detect <target>` before finalizing design changes.",
         "- Treat Impeccable findings as design-review signals: fix issues that affect clarity, consistency, accessibility or trust, and note when there is no suitable scan target.",
         "- After design decisions stabilize, replace the unconfigured marker, index the selected targets and authored token source/generation direction, and record durable tokens, component rules and do/don't guidance.",
+        "- Change an adopted target through its recorded upstream route, create or approve a new immutable version/digest, and update its index entry; never overwrite the adopted baseline in place.",
         "",
     ].join("\n");
 }

package/dist/lib/design-resource-handoff-file-primitives.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export type DesignResource = ParsedDesignResourceHandoffV1["handoff"]["resources"][number];
+export declare function htmlAttributes(source: string): Map<string, string>;
+export declare function isTextResource(resource: DesignResource): boolean;

package/dist/lib/design-resource-handoff-file-primitives.js

@@ -0,0 +1,14 @@
+export function htmlAttributes(source) {
+    const attributes = new Map();
+    for (const match of source.matchAll(/([A-Za-z_:][A-Za-z0-9_.:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu))
+        attributes.set(match[1].toLowerCase(), match[2] ?? match[3] ?? match[4] ?? "");
+    return attributes;
+}
+export function isTextResource(resource) {
+    return (resource.media_type.startsWith("text/") ||
+        [
+            "application/javascript",
+            "application/json",
+            "application/xhtml+xml",
+        ].includes(resource.media_type));
+}

package/dist/lib/design-resource-handoff-file-validation.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceFiles(repository: string, parsed: ParsedDesignResourceHandoffV1): Promise<void>;

package/dist/lib/design-resource-handoff-file-validation.js

@@ -0,0 +1,142 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { htmlAttributes, isTextResource, } from "./design-resource-handoff-file-primitives.js";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { validateDesignResourceWebDependencyClosure } from "./design-resource-handoff-web-dependency-validation.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { markdownAnchors } from "./long-task-source-validation.js";
+export async function validateDesignResourceFiles(repository, parsed) {
+    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
+    const contents = new Map();
+    for (const resource of parsed.handoff.resources) {
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource:${resource.key}`);
+        contents.set(resource.key, await readFile(file));
+    }
+    for (const evidence of parsed.handoff.evidence)
+        validateLocator(evidence, resources.get(evidence.resource_ref), contents.get(evidence.resource_ref));
+    for (const target of parsed.handoff.targets)
+        if (target.source_profile.kind === "implementation_web")
+            validateDesignResourceWebDependencyClosure(target, resources, contents);
+}
+function validateLocator(evidence, resource, bytes) {
+    const { kind, value } = evidence.locator;
+    const label = `${evidence.key}:${resource.key}:${kind}:${value}`;
+    validateEvidenceResourceCompatibility(evidence, resource);
+    if (kind === "whole_resource") {
+        if (value !== ".")
+            invalidDesignResourceHandoff("locator_whole_resource_value", label);
+        if (resource.media_type.startsWith("text/") &&
+            !["asset", "motion_capture", "frame"].includes(evidence.kind))
+            invalidDesignResourceHandoff("locator_whole_resource_too_broad", label);
+        return;
+    }
+    const content = bytes.toString("utf8");
+    if (kind === "html_selector") {
+        requireMediaType(resource, ["text/html", "application/xhtml+xml"], label);
+        if (!htmlSelectorExists(content, value))
+            invalidDesignResourceHandoff("locator_not_found", label);
+        return;
+    }
+    if (kind === "markdown_anchor") {
+        requireMediaType(resource, ["text/markdown"], label);
+        if (value.startsWith("#") || !markdownAnchors(content).has(value))
+            invalidDesignResourceHandoff("locator_not_found", label);
+        return;
+    }
+    if (kind === "json_pointer") {
+        requireMediaType(resource, ["application/json"], label);
+        if (!jsonPointerExists(content, value))
+            invalidDesignResourceHandoff("locator_not_found", label);
+        return;
+    }
+    if (kind === "css_selector") {
+        requireMediaType(resource, ["text/css"], label);
+        if (!cssSelectorExists(content, value))
+            invalidDesignResourceHandoff("locator_not_found", label);
+        return;
+    }
+    requireMediaType(resource, ["text/css"], label);
+    if (!/^--[A-Za-z0-9_-]+$/u.test(value))
+        invalidDesignResourceHandoff("locator_css_custom_property_invalid", label);
+    const customProperty = new RegExp(`${escapeRegExp(value)}\\s*:`, "u");
+    if (!customProperty.test(content))
+        invalidDesignResourceHandoff("locator_not_found", label);
+}
+function validateEvidenceResourceCompatibility(evidence, resource) {
+    const machineReadableKinds = new Set([
+        "prototype_transition",
+        "motion_spec",
+        "responsive_spec",
+        "input_spec",
+        "accessibility_spec",
+        "semantic_tree",
+        "token_spec",
+        "annotation",
+    ]);
+    if (machineReadableKinds.has(evidence.kind) && !isTextResource(resource))
+        invalidDesignResourceHandoff("evidence_resource_media_type_incompatible", `${evidence.key}:${evidence.kind}:${resource.media_type}`);
+}
+function requireMediaType(resource, expected, detail) {
+    if (!expected.includes(resource.media_type))
+        invalidDesignResourceHandoff("locator_media_type_incompatible", `${detail}:${resource.media_type}`);
+}
+function htmlSelectorExists(content, selector) {
+    const parsed = /^(?:([A-Za-z][A-Za-z0-9:-]*))?(?:#([A-Za-z][A-Za-z0-9_.:-]*))?(?:\[([A-Za-z_:][A-Za-z0-9_.:-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\]\s]+)))?\])?$/u.exec(selector);
+    if (!parsed || (!parsed[1] && !parsed[2] && !parsed[3]))
+        invalidDesignResourceHandoff("locator_html_selector_unsupported", selector);
+    const [, expectedTag, expectedId, expectedAttribute] = parsed;
+    const expectedValue = parsed[4] ?? parsed[5] ?? parsed[6];
+    for (const match of content.matchAll(/<([A-Za-z][A-Za-z0-9:-]*)\b([^<>]*)>/gu)) {
+        if (expectedTag && match[1].toLowerCase() !== expectedTag.toLowerCase())
+            continue;
+        const attributes = htmlAttributes(match[2]);
+        if (expectedId && attributes.get("id") !== expectedId)
+            continue;
+        if (expectedAttribute) {
+            const attributeName = expectedAttribute.toLowerCase();
+            if (!attributes.has(attributeName))
+                continue;
+            if (expectedValue !== undefined &&
+                attributes.get(attributeName) !== expectedValue)
+                continue;
+        }
+        return true;
+    }
+    return false;
+}
+function jsonPointerExists(content, pointer) {
+    if (!pointer.startsWith("/"))
+        return false;
+    let current;
+    try {
+        current = JSON.parse(content);
+    }
+    catch {
+        return false;
+    }
+    for (const token of pointer
+        .slice(1)
+        .split("/")
+        .map((part) => part.replace(/~1/gu, "/").replace(/~0/gu, "~"))) {
+        if (current === null ||
+            typeof current !== "object" ||
+            !Object.hasOwn(current, token))
+            return false;
+        current = current[token];
+    }
+    return true;
+}
+function cssSelectorExists(content, selector) {
+    if (!selector.trim() || selector.includes("{") || selector.includes("}"))
+        invalidDesignResourceHandoff("locator_css_selector_unsupported", selector);
+    for (const match of content.matchAll(/(?:^|\})\s*([^@{}][^{}]*)\{/gmu))
+        if (match[1]
+            .split(",")
+            .map((item) => item.trim())
+            .includes(selector))
+            return true;
+    return false;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}

package/dist/lib/design-resource-handoff-parser.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function containsDesignResourceHandoff(content: string): boolean;
+export declare function parseDesignResourceHandoffMarkdown(handoffPath: string, content: string): ParsedDesignResourceHandoffV1;

package/dist/lib/design-resource-handoff-parser.js

@@ -0,0 +1,29 @@
+import { parseDesignResourceHandoffShape } from "./design-resource-handoff-shape.js";
+import { parseSourceItems } from "./long-task-source-item-parser.js";
+import { parseStrictYaml } from "./strict-codec.js";
+const FENCE = /^```yaml[ \t]+design-resource-handoff-v1[ \t]*\r?\n([\s\S]*?)^```[ \t]*$/gmu;
+export function containsDesignResourceHandoff(content) {
+    FENCE.lastIndex = 0;
+    return FENCE.test(content);
+}
+export function parseDesignResourceHandoffMarkdown(handoffPath, content) {
+    FENCE.lastIndex = 0;
+    const blocks = [...content.matchAll(FENCE)];
+    if (blocks.length !== 1)
+        throw new Error(`design_resource_handoff_invalid:block_count:${handoffPath}:${blocks.length}`);
+    try {
+        const sourceItems = parseSourceItems(handoffPath, content);
+        return {
+            handoff_path: handoffPath,
+            handoff: parseDesignResourceHandoffShape(parseStrictYaml(blocks[0][1])),
+            source_item_keys: sourceItems.map((item) => item.key),
+            source_item_kinds: Object.fromEntries(sourceItems.map((item) => [item.key, item.kind])),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith("design_resource_handoff_invalid:"))
+            throw error;
+        throw new Error(`design_resource_handoff_invalid:shape:${message}`);
+    }
+}

package/dist/lib/design-resource-handoff-policy.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+export declare const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION: Record<DesignResourceDimension, readonly DesignResourceEvidenceKind[]>;
+export declare const DESIGN_RESOURCE_METHODS_BY_DIMENSION: Record<DesignResourceDimension, readonly DesignResourceVerificationMethod[]>;

package/dist/lib/design-resource-handoff-policy.js

@@ -0,0 +1,36 @@
+export const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION = {
+    surface_flow: [
+        "frame",
+        "prototype_state",
+        "prototype_transition",
+        "annotation",
+    ],
+    visual_content: ["frame", "component_variant", "token_spec", "annotation"],
+    component_control: [
+        "frame",
+        "component_variant",
+        "prototype_state",
+        "token_spec",
+        "annotation",
+    ],
+    state_interaction: [
+        "component_variant",
+        "prototype_state",
+        "prototype_transition",
+        "input_spec",
+    ],
+    motion: ["prototype_transition", "motion_spec", "motion_capture"],
+    adaptation_input: ["responsive_spec", "input_spec"],
+    accessibility: ["accessibility_spec", "semantic_tree", "input_spec"],
+    assets: ["asset", "token_spec", "annotation"],
+};
+export const DESIGN_RESOURCE_METHODS_BY_DIMENSION = {
+    surface_flow: ["layout_geometry", "interaction_trace"],
+    visual_content: ["visual_pixel", "design_token", "content"],
+    component_control: ["visual_pixel", "design_token", "component_state"],
+    state_interaction: ["component_state", "interaction_trace"],
+    motion: ["motion_timeline"],
+    adaptation_input: ["responsive_reflow", "input_method"],
+    accessibility: ["accessibility_semantics"],
+    assets: ["asset_integrity"],
+};

package/dist/lib/design-resource-handoff-shape-evidence.d.ts

@@ -0,0 +1,4 @@
+import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffCoverageV1, DesignResourceHandoffEvidenceV1 } from "./design-resource-handoff-types.js";
+export declare function parseDesignResourceHandoffEvidence(value: unknown): DesignResourceHandoffEvidenceV1[];
+export declare function parseDesignResourceHandoffCoverage(value: unknown): DesignResourceHandoffCoverageV1[];
+export declare function parseDesignResourceHandoffBlockers(value: unknown): DesignResourceHandoffBlockerV1[];

package/dist/lib/design-resource-handoff-shape-evidence.js

@@ -0,0 +1,84 @@
+import { DESIGN_RESOURCE_DIMENSIONS, DESIGN_RESOURCE_EVIDENCE_KINDS, DESIGN_RESOURCE_LOCATOR_KINDS, } from "./design-resource-handoff-types.js";
+import { contractKey, contractKeys, sourceItemKeys, stableKey, stableKeys, verificationMethods, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, object, string, } from "./long-task-shape-primitives.js";
+export function parseDesignResourceHandoffEvidence(value) {
+    return array(value, "design_resource_handoff.evidence").map((item, index) => {
+        const label = `design_resource_handoff.evidence[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "resource_ref",
+            "kind",
+            "locator",
+            "condition_refs",
+        ]);
+        const locator = object(row.locator, `${label}.locator`, ["kind", "value"]);
+        return {
+            key: stableKey(row.key, `${label}.key`),
+            resource_ref: stableKey(row.resource_ref, `${label}.resource_ref`),
+            kind: literal(row.kind, DESIGN_RESOURCE_EVIDENCE_KINDS, `${label}.kind`),
+            locator: {
+                kind: literal(locator.kind, DESIGN_RESOURCE_LOCATOR_KINDS, `${label}.locator.kind`),
+                value: string(locator.value, `${label}.locator.value`),
+            },
+            condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
+        };
+    });
+}
+export function parseDesignResourceHandoffCoverage(value) {
+    return array(value, "design_resource_handoff.coverage").map((item, index) => {
+        const label = `design_resource_handoff.coverage[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "subject_refs",
+            "dimension",
+            "disposition",
+            "target_refs",
+            "condition_refs",
+            "evidence_refs",
+            "source_item_refs",
+            "verification_methods",
+            "rationale",
+        ]);
+        return {
+            key: stableKey(row.key, `${label}.key`),
+            subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
+            dimension: literal(row.dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimension`),
+            disposition: literal(row.disposition, [
+                "covered",
+                "not_applicable",
+                "excluded_by_scope",
+                "decision_required",
+                "unavailable",
+            ], `${label}.disposition`),
+            target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
+            condition_refs: contractKeys(row.condition_refs, `${label}.condition_refs`),
+            evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
+            source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+            verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
+            rationale: string(row.rationale, `${label}.rationale`),
+        };
+    });
+}
+export function parseDesignResourceHandoffBlockers(value) {
+    return array(value, "design_resource_handoff.acceptance_blockers").map((item, index) => {
+        const label = `design_resource_handoff.acceptance_blockers[${index}]`;
+        const row = object(item, label, [
+            "key",
+            "target_refs",
+            "subject_refs",
+            "dimensions",
+            "source_item_refs",
+            "verification_methods",
+            "description",
+        ]);
+        return {
+            key: contractKey(row.key, `${label}.key`),
+            target_refs: contractKeys(row.target_refs, `${label}.target_refs`),
+            subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
+            dimensions: array(row.dimensions, `${label}.dimensions`).map((dimension, itemIndex) => literal(dimension, DESIGN_RESOURCE_DIMENSIONS, `${label}.dimensions[${itemIndex}]`)),
+            source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+            verification_methods: verificationMethods(row.verification_methods, `${label}.verification_methods`),
+            description: string(row.description, `${label}.description`),
+        };
+    });
+}

package/dist/lib/design-resource-handoff-shape-primitives.d.ts

@@ -0,0 +1,9 @@
+import type { DesignResourceHandoffCoverageV1 } from "./design-resource-handoff-types.js";
+export declare function stableKey(value: unknown, label: string): string;
+export declare function stableKeys(value: unknown, label: string): string[];
+export declare function contractKey(value: unknown, label: string): string;
+export declare function contractKeys(value: unknown, label: string): string[];
+export declare function sourceItemKeys(value: unknown, label: string): string[];
+export declare function verificationMethods(value: unknown, label: string): DesignResourceHandoffCoverageV1["verification_methods"];
+export declare function positiveInteger(value: unknown, label: string): number;
+export declare function designResourceShapeFail(label: string, message: string): never;

package/dist/lib/design-resource-handoff-shape-primitives.js

@@ -0,0 +1,44 @@
+import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
+import { array, literal, string } from "./long-task-shape-primitives.js";
+const KEY = /^[a-z0-9][a-z0-9._-]*$/u;
+const SOURCE_ITEM_KEY = /^[a-z0-9][a-z0-9-]*$/u;
+export function stableKey(value, label) {
+    const result = string(value, label);
+    if (!KEY.test(result))
+        designResourceShapeFail(label, "must match ^[a-z0-9][a-z0-9._-]*$");
+    return result;
+}
+export function stableKeys(value, label) {
+    return array(value, label).map((item, index) => stableKey(item, `${label}[${index}]`));
+}
+export function contractKey(value, label) {
+    const result = string(value, label);
+    if (!SOURCE_ITEM_KEY.test(result))
+        designResourceShapeFail(label, "must match ^[a-z0-9][a-z0-9-]*$");
+    return result;
+}
+export function contractKeys(value, label) {
+    return array(value, label).map((item, index) => contractKey(item, `${label}[${index}]`));
+}
+export function sourceItemKeys(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const result = string(item, itemLabel);
+        if (!SOURCE_ITEM_KEY.test(result))
+            designResourceShapeFail(itemLabel, "must be a valid ty-source-item key");
+        return result;
+    });
+}
+export function verificationMethods(value, label) {
+    return array(value, label).map((item, index) => literal(item, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}[${index}]`));
+}
+export function positiveInteger(value, label) {
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value <= 0)
+        designResourceShapeFail(label, "must be a positive safe integer");
+    return value;
+}
+export function designResourceShapeFail(label, message) {
+    throw new Error(`design_resource_handoff_invalid:${label}:${message}`);
+}

package/dist/lib/design-resource-handoff-shape-structure.d.ts

@@ -0,0 +1,5 @@
+import type { DesignResourceHandoffConditionV1, DesignResourceHandoffResourceV1, DesignResourceHandoffSubjectV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
+export declare function parseDesignResourceHandoffResources(value: unknown): DesignResourceHandoffResourceV1[];
+export declare function parseDesignResourceHandoffConditions(value: unknown): DesignResourceHandoffConditionV1[];
+export declare function parseDesignResourceHandoffSubjects(value: unknown): DesignResourceHandoffSubjectV1[];
+export declare function parseDesignResourceHandoffTargets(value: unknown): DesignResourceHandoffTargetV1[];