project-tiny-context-harness 0.8.8 → 0.8.11

package/assets/skills/design-resource-authoring/SKILL.md

@@ -5,7 +5,7 @@ description: Use when the user explicitly asks to generate, author, plan, commis
 
 # Design Resource Authoring
 
-Commission the smallest sufficient set of design resources for the explicitly requested output or development scope from live Open Design capabilities. “Smallest” governs artifact count and surrounding scope, never information granularity. For a formal selected Web/App implementation handoff, first derive the complete material in-scope Expected Fact Universe from requirements, product semantics, adopted design system, target platforms and observable conditions; then require canonical resources to express it and a frozen Inspector to enumerate it. The default identity is one atomic Fact Cell—not a Product Control, page, screenshot, broad dimension row or provider summary—and exact targets additionally require condition-specific full-target layout and pixel facts. This Skill is a thin task-local planner, provider adapter, iteration guide, final proposal reconciler and handoff layer; Open Design owns generation logic and Tiny Context owns neither its prompts nor runtime.
+Commission the smallest sufficient set of design resources for the explicitly requested output or development scope from live Open Design capabilities. “Smallest” governs artifact count and surrounding scope, never information granularity. For a formal selected Web/App implementation handoff, first derive the complete material in-scope Expected Fact Universe from requirements, product semantics, adopted design system, target platforms and observable conditions; then require canonical resources to express it and a frozen Inspector to enumerate it. The default identity is one atomic Fact Cell—not a Product Control, page, screenshot, broad dimension row or provider summary—and exact targets additionally require condition-specific full-target layout and pixel facts. This Skill is a thin task-local planner, provider adapter, iteration guide, final proposal reconciler and handoff layer; Open Design owns generation logic and Tiny Context owns neither its prompts nor runtime.
 
 ## Hard boundaries
 
@@ -14,10 +14,10 @@ Commission the smallest sufficient set of design resources for the explicitly re
 - Proposal reconciliation changes only the initial proposal: never mutate `project_context/**`, `DESIGN.md`, a Source Plan, Delivery Contract, production code or tests as a design-resource side effect.
 - Never make a prototype, wireframe, high-fidelity candidate, design-system slice, provider-native file, variant count or directory layout universally mandatory.
 - Treat the user's explicit output/development scope as the hard ceiling. Include only the surrounding context needed to design that slice.
-- Never require one artifact per control. Reuse selected component sources and group repeated controls by family; commission a dedicated study only for unique or complex uncovered meaning.
-- Do not confuse Product Control granularity with design-fact granularity. An image, text run, icon, component part, smaller visual primitive, layout relation, geometry/style/token/content/state/behavior fact remains independently material when the selected resource expresses it.
-- For a formal selected Web/App handoff, do not let initially generated output define its own obligation universe. Derive that universe before commissioning from scoped subjects, target conditions, subject-local variations and the atomic property catalog. A label such as `all-states`, one default page, representative screenshots, pairwise sampling or an Inspector `complete` Boolean cannot stand in for enumerated identities.
-- Artifact grouping and exact-value ownership remain separate: one HTML/CSS/JS/JSON/SVG source set may carry thousands of atomic facts. Exact values stay in that canonical source; the manifest, residual handoff and downstream Contract preserve typed locators, digests, comparison authority and Fact identities rather than copying CSS into a second value owner.
+- Never require one artifact per control. Reuse selected component sources and group repeated controls by family; commission a dedicated study only for unique or complex uncovered meaning.
+- Do not confuse Product Control granularity with design-fact granularity. An image, text run, icon, component part, smaller visual primitive, layout relation, geometry/style/token/content/state/behavior fact remains independently material when the selected resource expresses it.
+- For a formal selected Web/App handoff, do not let initially generated output define its own obligation universe. Derive that universe before commissioning from scoped subjects, target conditions, subject-local variations and the atomic property catalog. A label such as `all-states`, one default page, representative screenshots, pairwise sampling or an Inspector `complete` Boolean cannot stand in for enumerated identities.
+- Artifact grouping and exact-value ownership remain separate: one HTML/CSS/JS/JSON/SVG source set may carry thousands of atomic facts. Exact values stay in that canonical source; the manifest, residual handoff and downstream Contract preserve typed locators, digests, comparison authority and Fact identities rather than copying CSS into a second value owner.
 - Never infer that a page frame or prototype covers states, responsiveness, accessibility or interaction it does not explicitly specify or demonstrate.
 - Exploration and unselected previews stay schema-free. Only a final selected implementation handoff requires the shared strict Markdown adapter; this is input preparation, not a resource pack or acceptance result.
 - Design resources may express user-visible interaction and presentation, but must not invent or become sole owner of business, data, permission or algorithmic rules.
@@ -37,15 +37,15 @@ Commission the smallest sufficient set of design resources for the explicitly re
 2. **Inventory inputs.** Accept initial proposals, notes, product/technical plans, visual briefs, screenshots, references and existing resources. Preserve each role as exact target, constraint, inspiration, current-implementation evidence or background; report unreadable/unused material.
 3. **Classify visual-style dependency.** Mark the commission `style-bearing` when it materially expresses visual fidelity, brand, typography/color/density, component visual treatment or a production-style prototype. Mark it `non-fidelity` for IA/flow topology, low-fidelity structure, semantics-only behavior/state studies or an explicitly non-fidelity prototype. Mixed work is style-bearing unless split into an independent non-fidelity commission.
 4. **Apply the conditional Design Authority gate.** For style-bearing work, read `DESIGN.md` and its token source. If authority is unconfigured, stop before project/run creation and tell the user to explicitly invoke `$design-system-authoring`; do not invoke it automatically. A combined explicit request authorizes running that Skill first and then resuming this one. Non-fidelity work remains allowed.
-5. **Derive the authoring obligation universe before generation.** For a formal selected Web/App handoff, start from requested Surfaces/flows, product semantics, adopted design-system snapshot and target platforms—not from whatever a first render happens to contain. Enumerate stable subjects and hierarchy for every Surface, region, overlay/system UI, component family and instance, Control, Anatomy Part/slot, primitive, text, icon, media, asset and typed multi-subject relation. Explicitly disposition every standard condition axis—platform/OS/device/form factor, exact viewport, orientation, density, Safe Area, window/fold/display/color modes, locale/language/script/direction/pseudo-localization, content/data stress, text scale, input/assistive technology, motion/transparency/contrast/bold text/button shapes, system UI/IME, permission/capability/connectivity/lifecycle—plus scoped custom axes. For each subject enumerate `variant × state × interaction_phase × presence_phase × instance_case`, including compound precedence, conditional/lazy/virtualized/portal population and exact exclusions. Apply the standard atomic property catalog across geometry, layout/scroll, typography/color/decoration/content/icon/media, interaction/navigation/motion/feedback, responsive, accessibility, assets/system and relations; add inspector-declared custom properties without weakening the standard set. The Expected Fact Universe is the exact applicable `subject × target × condition × variation × property` cell set. Every cell is covered or has an exact source/basis-backed `not_applicable`/`excluded_by_scope`; `decision_required`/`unavailable` remains blocking. Continuous widths, text pressure and animation expose breakpoints/ranges/interpolation/reflow/timeline rules rather than only sampled snapshots. Never truncate, sample, summarize the remainder or let aggregate strings such as `all-states` impersonate atomic identities.
+5. **Derive the authoring obligation universe before generation.** For a formal selected Web/App handoff, start from requested Surfaces/flows, product semantics, adopted design-system snapshot and target platforms—not from whatever a first render happens to contain. Enumerate stable subjects and hierarchy for every Surface, region, overlay/system UI, component family and instance, Control, Anatomy Part/slot, primitive, text, icon, media, asset and typed multi-subject relation. Explicitly disposition every standard condition axis—platform/OS/device/form factor, exact viewport, orientation, density, Safe Area, window/fold/display/color modes, locale/language/script/direction/pseudo-localization, content/data stress, text scale, input/assistive technology, motion/transparency/contrast/bold text/button shapes, system UI/IME, permission/capability/connectivity/lifecycle—plus scoped custom axes. For each subject enumerate `variant × state × interaction_phase × presence_phase × instance_case`, including compound precedence, conditional/lazy/virtualized/portal population and exact exclusions. Apply the standard atomic property catalog across geometry, layout/scroll, typography/color/decoration/content/icon/media, interaction/navigation/motion/feedback, responsive, accessibility, assets/system and relations; add inspector-declared custom properties without weakening the standard set. The Expected Fact Universe is the exact applicable `subject × target × condition × variation × property` cell set. Every cell is covered or has an exact source/basis-backed `not_applicable`/`excluded_by_scope`; `decision_required`/`unavailable` remains blocking. Continuous widths, text pressure and animation expose breakpoints/ranges/interpolation/reflow/timeline rules rather than only sampled snapshots. Never truncate, sample, summarize the remainder or let aggregate strings such as `all-states` impersonate atomic identities.
 6. **Discover live capabilities.** Inspect the current Open Design agent/model, skills, templates, design systems, plugins and export paths. Treat absent/non-enumerable capabilities honestly.
 7. **Choose the minimum sufficient commission.** Give each considered resource `selected`, `optional`, `not-needed`, `unavailable` or `decision-required` with one reason. Ask only when a missing preference materially changes the commission.
-8. **Bind and commission through Open Design.** For style-bearing work, create or verify the Open Design project with the adopted design-system ID and require `get_project.designSystemId` to match. Send the bounded product commission and the derived obligation universe through structured MCP: require the canonical implementation source to encode every applicable atomic value/behavior and require explicit dispositions for non-applicable, excluded or unresolved cells. Use documented fallbacks only when required; if the live provider cannot emit/read a required fact family, preserve that gap as blocking rather than silently narrowing the commission.
-9. **Acquire complete canonical source and its independent Fact manifest.** For Web/App implementation handoff, require Open Design to emit a canonical machine-readable entry, the full locally resolvable dependency set and one `design-resource-observable-fact-manifest-v1` inside that closure—not only a screenshot, preview or prose spec. The manifest freezes the design-system snapshot; exact Inspector identity/version/digest or named external TCB, capabilities, input paths/digests, complete enumeration and dynamic-discovery policy; addressable resource/node/declaration/token/asset/relation/variant/state/interaction/dynamic-population Census; all condition and variation axes/combinations; subject hierarchy; property catalog; Fact Cells/Facts; value and design-system lineage; evidence; Fact × required-method proof obligations; comparator/tolerance/mask, Oracle and render-environment authority; asset bindings; blockers; and non-sampling/non-truncating collection counts/digests. Enumerate and retrieve every selected file without truncation, preserve exact bytes/digests, record one `implementation_web` or `implementation_app` source profile with `acquisition: complete`, and make all local source, token, SVG, font, image, media, worker and asset dependencies resolve inside that frozen set. Non-Web resources use the bounded `reference` profile and are not forced into HTML.
-10. **Inspect, compare and iterate to exact closure.** Run the frozen Inspector over the frozen canonical entry/dependencies. Require every Census item to map to Facts/Fact Cells or a source/basis-backed `non_material` disposition, and require the manifest Fact universe to equal the precommission Expected Fact Universe. Exercise every required verification method with its method-compatible evidence, comparator, Oracle and environment; preserve design-system token/override/conflict lineage and exact asset consumers. Iterate the provider until `Expected Fact Universe = Canonical Resource Facts = Handoff Indexed Facts` can hold. Keep provider execution, artifact readiness and design suitability separate, and keep proposal effects only in the delta buffer while candidates remain unsettled.
+8. **Bind and commission through Open Design.** For style-bearing work, create or verify the Open Design project with the adopted design-system ID and require `get_project.designSystemId` to match. Send the bounded product commission and the derived obligation universe through structured MCP: require the canonical implementation source to encode every applicable atomic value/behavior and require explicit dispositions for non-applicable, excluded or unresolved cells. Use documented fallbacks only when required; if the live provider cannot emit/read a required fact family, preserve that gap as blocking rather than silently narrowing the commission.
+9. **Acquire complete canonical source and its independent Fact manifest.** For Web/App implementation handoff, require Open Design to emit a canonical machine-readable entry, the full locally resolvable dependency set and one `design-resource-observable-fact-manifest-v1` inside that closure—not only a screenshot, preview or prose spec. The manifest freezes the design-system snapshot; exact Inspector identity/version/digest or named external TCB, capabilities, input paths/digests, complete enumeration and dynamic-discovery policy; addressable resource/node/declaration/token/asset/relation/variant/state/interaction/dynamic-population Census; all condition and variation axes/combinations; subject hierarchy; property catalog; Fact Cells/Facts; value and design-system lineage; evidence; Fact × required-method proof obligations; comparator/tolerance/mask, Oracle and render-environment authority; asset bindings; blockers; and non-sampling/non-truncating collection counts/digests. Enumerate and retrieve every selected file without truncation, preserve exact bytes/digests, record one `implementation_web` or `implementation_app` source profile with `acquisition: complete`, and make all local source, token, SVG, font, image, media, worker and asset dependencies resolve inside that frozen set. Non-Web resources use the bounded `reference` profile and are not forced into HTML.
+10. **Inspect, compare and iterate to exact closure.** Run the frozen Inspector over the frozen canonical entry/dependencies. Require every Census item to map to Facts/Fact Cells or a source/basis-backed `non_material` disposition, and require the manifest Fact universe to equal the precommission Expected Fact Universe. Exercise every required verification method with its method-compatible evidence, comparator, Oracle and environment; preserve design-system token/override/conflict lineage and exact asset consumers. Iterate the provider until `Expected Fact Universe = Canonical Resource Facts = Handoff Indexed Facts` can hold. Keep provider execution, artifact readiness and design suitability separate, and keep proposal effects only in the delta buffer while candidates remain unsettled.
 11. **Finalize selection and reconcile once.** After explicit human selection or explicit delegated selection, preserve immutable identity and consolidate accepted, rejected and unresolved effects. Apply only accepted decisions once to a writable initial-proposal file; if it exists only in conversation, return one complete revised proposal. Preserve original intent/provenance and make reruns idempotent. Do not write unresolved or rejected choices as requirements.
-12. **Compile the residual implementation handoff when requested.** For final selected resources intended for development, write one project-native Markdown Source at an authorized path. Preserve readable `ty-source-item` facts and exactly one fenced `design-resource-handoff-v1` YAML block. Keep exact code-expressible UI values in canonical resources; project their stable identities through typed, locally resolvable located digests instead of copying values into a second authority. The residual block must be exactly equal to the target manifest for axes/exclusions/conditions, subjects, variations, properties, lineage, Fact Cells/Facts, evidence, proof obligations, Oracles, environments, asset bindings and blockers. Each covered Fact Cell binds one Fact; each Fact binds its atomic subject/target/condition/variation/property, value kind, sensitivity, value/lineage/evidence/Source; each required method has its own proof obligation with comparator parameters, exact/tolerance mode, optional authoritative mask, Oracle and environment. Close every resource as `material_with_facts` or honestly `supporting_only`; extend roll-up coverage to exact `subject/target/condition/variation/property/fact-cell/fact/proof` sets. Every exact target needs full-target `layout_geometry` and `visual_pixel` Facts per condition. Run `ty-context design-resource preflight <handoff.md>`. Any mismatch with the manifest/Expected Universe, ambiguous profile key, unenumerated Census item, missing standard axis/property/method, aggregate identity, sampling/truncation, unresolved locator/dependency/lineage/conflict, unsafe sensitive observation, `decision_required`/`unavailable`, blocker, stale digest or unsupported evidence blocks `ready`. Do not create this file for exploration.
-13. **Return an intent-sized result.** Exploration shows the artifact promptly. An implementation handoff returns the validated handoff path, selected immutable resources, stable-key coverage, provenance, binding, limitations and preflight result. Include the reconciled initial proposal or its updated path when final selection occurred.
+12. **Compile the residual implementation handoff when requested.** Keep each canonical per-target `design-resource-observable-fact-manifest-v1` as the sole complete index for Inspector inputs/Census, axes and exclusions, conditions, subjects and variations, properties and lineage, Fact Cells/Facts, evidence/proofs, Oracles/environments, assets and blockers. Do not copy those collections into handoff YAML. For each target, author one small project-native Markdown draft with readable, target-attributed `ty-source-item` facts and exactly one fenced `design-resource-handoff-v1` block whose `representation` is `manifest_backed`. The block contains only residual scope/provenance, resource identities, that one target/profile, resource-fact closure, coverage and proposal binding. Shared meaning is atomized into uniquely keyed target-attributed Source facts without dropping its original predicate or provenance. Freeze the explicit canonical manifest path set and choose an actual UTF-8 byte ceiling before draft generation. Ensure the authorized output parent already exists, then call `ty-context design-resource bundle <draft-dir> <new-output-dir> --manifest <facts.json> [...] --max-handoff-bytes <bytes>`. The command rejects embedded/full-array drafts, multi-target drafts, over-budget descriptors, missing/extra/duplicate targets, manifest path/SHA drift, invalid collection count/identity digests, any normalized preflight failure and any existing final directory; it processes one target at a time in a same-volume temporary directory and publishes the complete target set with one atomic directory rename. Validation is an invariant check on the already compact representation, never a post-hoc splitting pass. On failure only the command-owned temporary directory is removed; drafts and existing/adopted handoffs remain unchanged. Do not author the older embedded V1 representation; it remains readable only for compatibility. Preflight hydrates the omitted collections directly from the declared canonical manifest snapshot and runs the same full semantic validator, so `Expected Fact Universe = Canonical Resource Facts = Handoff Indexed Facts` remains exact without duplicate YAML. File/model/parser/memory pressure never permits pruning, sampling, truncation, coarser Facts, implicit defaults or broader exclusions. If the truthful residual descriptor cannot meet the declared byte ceiling, treat the ceiling as incompatible and fail closed; never split a semantic target. Do not create these files for exploration.
+13. **Return an intent-sized result.** Exploration shows the artifact promptly. An implementation handoff returns the atomically published handoff directory and every target/path mapping, selected immutable resources, stable-key coverage, manifest path/SHA plus collection count/identity-digest conservation, provenance, binding, limitations and successful bundle/preflight result. Include the reconciled initial proposal or its updated path when final selection occurred.
 
 ## Conditional Design Authority gate
 
@@ -85,4 +85,4 @@ Small requests may complete generation, selection and reconciliation in one turn
 
 ## Completion response
 
-Report scope, necessary context/exclusions, style dependency and gate result; selected/omitted/unavailable resources; visible artifacts/typed locators; provider, project/run and design-system binding status; review and selection basis; immutable provenance; implementation source profile, entry/dependency closure and acquisition completeness when applicable; material applicability/coverage and unresolved decisions; proposal reconciliation status/path; and forbidden inferences. For implementation intent, report the residual `design-resource-handoff-v1` path and successful shared preflight; never call a failing or unresolved handoff ready.
+Report scope, necessary context/exclusions, style dependency and gate result; selected/omitted/unavailable resources; visible artifacts/typed locators; provider, project/run and design-system binding status; review and selection basis; immutable provenance; implementation source profile, entry/dependency closure and acquisition completeness when applicable; material applicability/coverage and unresolved decisions; proposal reconciliation status/path; and forbidden inferences. For implementation intent, report the published directory, every target-to-handoff mapping, canonical manifest path/SHA and collection count/identity-digest conservation, and successful bundle/preflight result; never call a failing, unresolved or incomplete target set ready.

package/assets/skills/design-resource-authoring/references/downstream-handoff.md

@@ -16,15 +16,15 @@ For every material in-scope surface/flow/region/component/control condition, rec
 
 Design resources may show user-visible triggers, transitions, states, feedback and product-rule presentation. Business, data, permission and algorithmic rules remain owned by product/technical Source and must not be invented by visuals.
 
-Canonical implementation resources own exact code-expressible layout, visual, content, state, interaction, adaptation, motion, semantic and asset values. The structured handoff is the residual semantic and index layer for scope, applicability and downstream binding: it projects every observable Fact through typed located digests, records complete inspection/proof closure and is not a second numeric/style source. Product Controls remain semantic interaction units and do not cap Fact granularity; addressable images, text, icons, component instances and Anatomy Parts, smaller primitives, relations, geometry/style/token/content/state/behavior facts remain independently queryable. For a formal selected Web/App target, completeness is:
-
-```text
-Expected Fact Universe
-  = Canonical Resource Facts enumerated by the frozen Inspector
-  = Handoff Indexed Facts
-```
-
-The Expected Universe is derived before generation from scoped requirements, product semantics, the adopted design system, target environments, stable subjects, condition axes, subject-local variation axes and the atomic property catalog. It is not whatever an initially generated default page happens to expose.
+Canonical implementation resources own exact code-expressible layout, visual, content, state, interaction, adaptation, motion, semantic and asset values. The canonical per-target observable-Fact manifest is the sole complete index of every Fact Cell, Fact and proof. The Markdown handoff is only the residual semantic and binding layer for scope, resources, target profile, resource closure, coverage, Source and proposal identity; preflight hydrates a normalized full handoff from the immutable manifest snapshot. Product Controls remain semantic interaction units and do not cap Fact granularity; addressable images, text, icons, component instances and Anatomy Parts, smaller primitives, relations, geometry/style/token/content/state/behavior facts remain independently queryable. For a formal selected Web/App target, completeness is:
+
+```text
+Expected Fact Universe
+  = Canonical Resource Facts enumerated by the frozen Inspector
+  = Handoff Indexed Facts
+```
+
+The Expected Universe is derived before generation from scoped requirements, product semantics, the adopted design system, target environments, stable subjects, condition axes, subject-local variation axes and the atomic property catalog. It is not whatever an initially generated default page happens to expose.
 
 ## Final proposal reconciliation
 
@@ -72,52 +72,61 @@ Return scope/intent, visible candidates, resource dispositions, obvious limitati
 
 ### Implementation handoff
 
-After final selection for implementation, add one project-native Markdown Source at an authorized repository path. It is ordinary Source, not a pack or Authority. Frozen canonical resources carry addressable implementation facts, while this residual handoff closes scope, applicability, uncovered meaning, product/technical semantics, blockers and downstream bindings. The file contains readable `ty-source-item:start/end` facts plus exactly one:
+After final selection for implementation, add one or more project-native Markdown Source files at authorized repository paths. They are ordinary Source, not a pack or Authority. Frozen canonical resources carry addressable implementation facts, while the residual handoff files close scope, applicability, uncovered meaning, product/technical semantics, blockers and downstream bindings. Each physical file contains readable `ty-source-item:start/end` facts plus exactly one:
 
 ````markdown
 ```yaml design-resource-handoff-v1
-...
+schema_version: design-resource-handoff-v1
+representation: manifest_backed
+# residual scope/resource/target/closure/coverage/proposal fields only
 ```
 ````
 
-The strict block includes:
-
-- output/development scope, necessary context and exclusions;
-- stable resource, subject, surface/control/state and target keys;
-- selected exact-target/constraint/supporting classification; candidates and inspiration do not enter covered implementation rows;
-- provider version, project/run, capability/template, agent/model and live design-system binding;
-- each repository-local immutable resource path, media type and exact SHA-256;
-- for implementation Web/App targets, a canonical entry, complete locally resolvable dependency set, one canonical `design-resource-observable-fact-manifest-v1` inside that set and `acquisition: complete`; non-Web resources use `reference` and are not forced into HTML;
-- editable upstream owner, locator and update/export method, or an explicit manual/external-update boundary when unavailable;
-- a frozen Inspector identity/version/digest or named external TCB; exact capabilities, canonical entry, all input resource paths/digests, `complete_enumeration`, fully enumerated dynamic discovery and an addressable Census of every material resource/node/declaration/token/asset/relation/custom property/variant/state/interaction phase/dynamic population item;
-- each Census row bound to exact Fact/Fact Cell sets or a source/basis-backed `non_material` rationale. An Inspector `complete` Boolean, resource count or provider statement does not replace the Census;
-- all 33 standard target-condition axes—platform, OS, device profile, form factor, exact viewport width/height, orientation, density/pixel ratio, Safe Area insets, window/fold/display/color modes, locale/language/script/direction/pseudo-localization, content/data stress, text scale/multiplier, input/assistive technology, motion/transparency/contrast/bold text/button shapes, system UI/IME, permission/capability/connectivity/lifecycle—plus scoped custom axes. Each has an explicit applicable/not-applicable disposition and stable values; reuse of one viewport/density/Safe-Area/text-scale key with conflicting geometry is invalid;
-- the complete target-condition Cartesian universe, with every applicable combination present and every omitted combination carrying an exact source/basis-backed exclusion. Continuous viewport/text-pressure behavior additionally exposes exact breakpoints, ranges, interpolation and reflow rules;
-- stable subjects for every in-scope Surface, flow, region, overlay/system UI, component family and instance, Control, Anatomy Part/slot, primitive, text, icon, media, asset and typed multi-subject relation; exact parent/instance/family/override/slot/portal/presence/population/Census lineage prevents a family or one rendered instance from hiding internal or repeated subjects;
-- for every subject, explicit `variant`, `state`, `interaction_phase`, `presence_phase` and `instance_case` axis dispositions plus the complete compound variation universe and exact exclusions. Labels such as `all-21-state-catalog` cannot impersonate 21 atomic states;
-- the complete standard atomic property catalog plus justified inspector-declared custom properties. Properties carry stable key, family, UI/UX dimension, typed value kind, required verification methods, Inspector capabilities and Census lineage. The eight dimensions—`surface_flow`, `visual_content`, `component_control`, `state_interaction`, `motion`, `adaptation_input`, `accessibility`, `assets`—remain reporting roll-ups, not the Fact ceiling;
-- one explicit Fact Cell for every applicable `subject × target × condition × variation × property` identity. Every cell is `covered`, source/basis-backed `not_applicable`/`excluded_by_scope`, or blocking `decision_required`/`unavailable`; sampling, pairwise coverage, summaries and implicit defaults are forbidden;
-- one atomic Fact for every covered cell, carrying exactly one subject/target/condition/variation/property, dimension, `subject|full_target` observation scope, `plain|protected` sensitivity, typed value kind, canonical value located digest, same-target/condition evidence, Source-item lineage and effective design-system lineage. Exact token/alias/platform/mode/state/instance overrides and resolved conflicts remain traceable;
-- typed, locally resolvable value/evidence locators for HTML/CSS/JS/JSON/Markdown/SVG or bounded binary whole-resource identity. Critical values cannot live only in a bitmap, preview or prose. Exact values stay in canonical resources; the handoff preserves locator/digest identity rather than copying CSS;
-- separate `proof_obligations` for every Fact × property-required verification method. Each names method-compatible evidence, comparator, exact/tolerance mode, canonical parameter/tolerance and optional narrow mask located digests, one frozen executable or named external Oracle with method capability, and one frozen render environment. A Fact needing token and pixel proof keeps both;
-- exact asset bindings to asset subjects, immutable resources, target/condition Facts and consumer subjects, including density/platform/theme/mode/locale variants, crop/focal/mask/placeholder/error/decode/fallback behavior;
-- generation metadata proving `complete_explicit`, `sampling: forbidden`, `truncation: forbidden`, contiguous chunk indexes, and exact count plus identity digest for every Inspector input/Census, axis, condition, subject, variation, property, lineage, Fact Cell/Fact, evidence/proof, Oracle/environment, asset and blocker collection;
-- exact manifest↔handoff row/set equality for every projected collection, so the residual handoff cannot certify its own narrower universe;
-- exactly one `resource_fact_closure` entry per resource with named complete inspection, rationale and either `material_with_facts` plus the exact Fact set or honestly `supporting_only` plus no Facts;
-- roll-up coverage whose subject/target/condition/variation/property/Fact Cell/Fact/proof/evidence/Source/method sets exactly equal their indexed unions; every Fact Cell, Fact and proof appears exactly once in coverage;
-- for every `exact_target` condition, one `full_target` `layout_geometry` fact and one `full_target` `visual_pixel` fact backed by exact-target evidence; if complete visible fidelity cannot be extracted/compared, keep the resource a `constraint` or unresolved;
-- source/Inspector-backed rationales for every non-applicable/excluded cell; unresolved rows remain visible and make preflight fail;
-- target-local acceptance blockers with exact target/subject/dimension/Source-item/verification-method lineage and a non-empty `required_capabilities` set; use the narrowest truthful capability such as physical device, sensor, camera, orientation, haptic, screen reader, pixel-density, safe-area, input or production runtime rather than weakening it to an available proxy;
-- selection basis, proposal reconciliation path/status and known limitations;
-- outer review and separate provider/artifact/design qualifiers.
-
-Unknown fields fail closed. Every resource must be inspected; a material resource cannot be hidden as `supporting_only`, and unsupported/unreadable extraction remains blocking inside the named Inspector/Oracle TCB. All `decision_required`, `unavailable` and acceptance blockers prevent a `ready` result. A static frame may support only visible layout/visual/component Facts for its shown condition; pixel evidence cannot cover unseen interaction, motion, adaptation/input or accessibility. Protected Facts retain canonical-source ownership while downstream observations use attributable digest-only or redacted representations and never persist raw sensitive values. Run:
+Freeze the explicit canonical manifest path set and its target/scope identities, file SHA-256 values, and exact per-collection counts/identity digests before generating Markdown. Choose a truthful UTF-8 ceiling, then author one small draft per target. Each block keeps the shipped `design-resource-handoff-v1` marker and adds `representation: manifest_backed`; it does not repeat the manifest-owned arrays. Keep shared meaning as uniquely keyed, target-attributed Source facts without weakening the original predicate or provenance. Ensure the authorized output parent already exists, then run one bundle command over the complete draft and manifest sets. It rejects any embedded/full-array or multi-target draft, over-budget descriptor, missing/extra/duplicate target, stale manifest identity, invalid generation digest or normalized preflight failure; processes targets sequentially in a same-volume command-owned temporary directory; and atomically renames the complete set to a previously nonexistent final directory. Failure removes only that temporary directory. Drafts and existing/adopted handoffs are never overwritten, split or rewritten. The byte check is a guard on the already compact representation, not a post-hoc split. If truthful residual Source/scope/resource/closure/coverage/proposal data cannot meet the selected ceiling, the ceiling is incompatible and publication fails closed; a semantic target is never divided. File size, parser capacity, model output or memory pressure never permits sampling, truncation, Fact coarsening, implicit defaults or broader N/A/exclusions.
+
+Each strict YAML block includes only:
+
+- output/development scope, necessary context and exclusions;
+- stable resource and exactly one target identity;
+- selected exact-target/constraint/supporting classification; candidates and inspiration do not enter covered implementation rows;
+- provider version, project/run, capability/template, agent/model and live design-system binding;
+- each repository-local immutable resource path, media type and exact SHA-256;
+- for implementation Web/App targets, a canonical entry, complete locally resolvable dependency set, one canonical `design-resource-observable-fact-manifest-v1` inside that set and `acquisition: complete`; non-Web resources use `reference` and are not forced into HTML;
+- editable upstream owner, locator and update/export method, or an explicit manual/external-update boundary when unavailable;
+- exactly one `resource_fact_closure` entry per resource, roll-up coverage with exact manifest-owned references, proposal reconciliation identity and readable target-attributed Source Items.
+
+The referenced canonical manifest plus this residual block normalize to the complete handoff and therefore additionally include:
+
+- a frozen Inspector identity/version/digest or named external TCB; exact capabilities, canonical entry, all input resource paths/digests, `complete_enumeration`, fully enumerated dynamic discovery and an addressable Census of every material resource/node/declaration/token/asset/relation/custom property/variant/state/interaction phase/dynamic population item;
+- each Census row bound to exact Fact/Fact Cell sets or a source/basis-backed `non_material` rationale. An Inspector `complete` Boolean, resource count or provider statement does not replace the Census;
+- all 33 standard target-condition axes—platform, OS, device profile, form factor, exact viewport width/height, orientation, density/pixel ratio, Safe Area insets, window/fold/display/color modes, locale/language/script/direction/pseudo-localization, content/data stress, text scale/multiplier, input/assistive technology, motion/transparency/contrast/bold text/button shapes, system UI/IME, permission/capability/connectivity/lifecycle—plus scoped custom axes. Each has an explicit applicable/not-applicable disposition and stable values; reuse of one viewport/density/Safe-Area/text-scale key with conflicting geometry is invalid;
+- the complete target-condition Cartesian universe, with every applicable combination present and every omitted combination carrying an exact source/basis-backed exclusion. Continuous viewport/text-pressure behavior additionally exposes exact breakpoints, ranges, interpolation and reflow rules;
+- stable subjects for every in-scope Surface, flow, region, overlay/system UI, component family and instance, Control, Anatomy Part/slot, primitive, text, icon, media, asset and typed multi-subject relation; exact parent/instance/family/override/slot/portal/presence/population/Census lineage prevents a family or one rendered instance from hiding internal or repeated subjects;
+- for every subject, explicit `variant`, `state`, `interaction_phase`, `presence_phase` and `instance_case` axis dispositions plus the complete compound variation universe and exact exclusions. Labels such as `all-21-state-catalog` cannot impersonate 21 atomic states;
+- the complete standard atomic property catalog plus justified inspector-declared custom properties. Properties carry stable key, family, UI/UX dimension, typed value kind, required verification methods, Inspector capabilities and Census lineage. The eight dimensions—`surface_flow`, `visual_content`, `component_control`, `state_interaction`, `motion`, `adaptation_input`, `accessibility`, `assets`—remain reporting roll-ups, not the Fact ceiling;
+- one explicit Fact Cell for every applicable `subject × target × condition × variation × property` identity. Every cell is `covered`, source/basis-backed `not_applicable`/`excluded_by_scope`, or blocking `decision_required`/`unavailable`; sampling, pairwise coverage, summaries and implicit defaults are forbidden;
+- one atomic Fact for every covered cell, carrying exactly one subject/target/condition/variation/property, dimension, `subject|full_target` observation scope, `plain|protected` sensitivity, typed value kind, canonical value located digest, same-target/condition evidence, Source-item lineage and effective design-system lineage. Exact token/alias/platform/mode/state/instance overrides and resolved conflicts remain traceable;
+- typed, locally resolvable value/evidence locators for HTML/CSS/JS/JSON/Markdown/SVG or bounded binary whole-resource identity. Critical values cannot live only in a bitmap, preview or prose. Exact values stay in canonical resources; the handoff preserves locator/digest identity rather than copying CSS;
+- separate `proof_obligations` for every Fact × property-required verification method. Each names method-compatible evidence, comparator, exact/tolerance mode, canonical parameter/tolerance and optional narrow mask located digests, one frozen executable or named external Oracle with method capability, and one frozen render environment. A Fact needing token and pixel proof keeps both;
+- exact asset bindings to asset subjects, immutable resources, target/condition Facts and consumer subjects, including density/platform/theme/mode/locale variants, crop/focal/mask/placeholder/error/decode/fallback behavior;
+- generation metadata proving `complete_explicit`, `sampling: forbidden`, `truncation: forbidden`, contiguous chunk indexes, and exact count plus identity digest for every Inspector input/Census, axis, condition, subject, variation, property, lineage, Fact Cell/Fact, evidence/proof, Oracle/environment, asset and blocker collection;
+- hydration from the declared manifest bytes for every manifest-owned collection, so the residual handoff cannot restate or certify a narrower universe;
+- roll-up coverage whose subject/target/condition/variation/property/Fact Cell/Fact/proof/evidence/Source/method sets exactly equal their indexed unions; every Fact Cell, Fact and proof appears exactly once in coverage;
+- for every `exact_target` condition, one `full_target` `layout_geometry` fact and one `full_target` `visual_pixel` fact backed by exact-target evidence; if complete visible fidelity cannot be extracted/compared, keep the resource a `constraint` or unresolved;
+- source/Inspector-backed rationales for every non-applicable/excluded cell; unresolved rows remain visible and make preflight fail;
+- target-local acceptance blockers with exact target/subject/dimension/Source-item/verification-method lineage and a non-empty `required_capabilities` set; use the narrowest truthful capability such as physical device, sensor, camera, orientation, haptic, screen reader, pixel-density, safe-area, input or production runtime rather than weakening it to an available proxy;
+- selection basis, proposal reconciliation path/status and known limitations;
+- outer review and separate provider/artifact/design qualifiers.
+
+Unknown fields fail closed. Every resource must be inspected; a material resource cannot be hidden as `supporting_only`, and unsupported/unreadable extraction remains blocking inside the named Inspector/Oracle TCB. All `decision_required`, `unavailable` and acceptance blockers prevent a `ready` result. A static frame may support only visible layout/visual/component Facts for its shown condition; pixel evidence cannot cover unseen interaction, motion, adaptation/input or accessibility. Protected Facts retain canonical-source ownership while downstream observations use attributable digest-only or redacted representations and never persist raw sensitive values. Publish the complete set:
 
 ```text
-ty-context design-resource preflight <handoff.md>
+ty-context design-resource bundle <draft-dir> <new-output-dir> \
+  --manifest <facts.json> [--manifest <facts.json> ...] \
+  --max-handoff-bytes <bytes>
 ```
 
-Do not call the handoff ready until it passes. Passing proves acquisition, integrity and exact declared-universe closure relative to the frozen Inspector/Oracle TCB; it does not prove production implementation conformance. Exploration, candidates and unselected previews still require no file, schema, hash sequence or validator. There is no fixed directory, one-file-per-Control or one-file-per-Fact requirement.
+`ty-context design-resource preflight <handoff.md>` remains available for one-file inspection and for older embedded V1 read compatibility, but new DSA authoring uses `bundle`. Do not call the handoff set ready until bundle publication succeeds. Passing proves acquisition, integrity and exact declared-universe closure relative to the frozen Inspector/Oracle TCB; it does not prove production implementation conformance. Exploration, candidates and unselected previews still require no file, schema, hash sequence or validator. There is no fixed directory, one-file-per-Control or one-file-per-Fact requirement.
 
 ## Recommended downstream routing
 
@@ -127,7 +136,7 @@ initial proposal
   -> selected immutable resources
      + complete canonical implementation resources
      + reconciled initial proposal
-  -> validated residual design-resource-handoff-v1
+  -> validated manifest-backed design-resource-handoff-v1 target file(s)
   -> long-task-workflow (explicit long delivery)
      OR current native Goal + default Workflow Contract (non-long delivery)
 ```
@@ -136,11 +145,11 @@ initial proposal
 
 ### Default Workflow consumption
 
-The consuming Goal brings the revised proposal, selected resources and residual handoff as ordinary Source. It reruns shared preflight before UI Authority Closure, opens affected exact/constraint resources before deciding, classifies coverage, decides `Context Delta`, and makes every adopted decision-relevant target Context-reachable through existing owners. It keeps one ephemeral exact accounting of every Fact Cell, Fact and Fact × method obligation; routes each through the production owner and real-entry check; compares the current candidate with the frozen expected locator/digest using the declared comparator/tolerance/mask, Oracle and environment; and retains an attributable per-Fact actual observation and pass/fail verdict. Any unread, unsupported, unmapped, unimplemented, unverified, stale, failed or indistinguishable applicable Fact blocks the complete claim. A later update creates a new immutable version rather than overwriting the adopted baseline.
+The consuming Goal brings the revised proposal, selected resources and every residual handoff file as ordinary Source. It reruns shared preflight per file, proves the exact target set before UI Authority Closure, opens affected exact/constraint resources before deciding, classifies coverage, decides `Context Delta`, and makes every adopted decision-relevant target Context-reachable through existing owners. It keeps one ephemeral exact accounting of every Fact Cell, Fact and Fact × method obligation; routes each through the production owner and real-entry check; compares the current candidate with the frozen expected locator/digest using the declared comparator/tolerance/mask, Oracle and environment; and retains an attributable per-Fact actual observation and pass/fail verdict. Any unread, unsupported, unmapped, unimplemented, unverified, stale, failed or indistinguishable applicable Fact blocks the complete claim. A later update creates a new immutable version rather than overwriting the adopted baseline.
 
 ### Long-Task consumption
 
-The same revised proposal, selected resources and validated residual handoff enter `long-task-workflow`'s Source-bound Contract Draft loop immediately. The marked handoff is `task.source_paths`; each Contract design target's frozen `source_paths` and Check `verification_inputs` equal that handoff plus every declared resource path and condition. Covered Source Items map through `source_claims` to the root conformance Assertion. Every verification method maps to an independently failing Assertion carrying its relevant Source Claims; each method × condition evidence cell carries exact handoff `fact_refs` plus canonical `fact_expectations` for subject/variation/property, sensitivity, expected located digest, comparator/parameters/tolerance/mask, Oracle and environment. Their exact union equals the target Fact set and all property-required Fact × method obligations. Current typed `design_method` evidence repeats the exact Fact set and supplies one `fact_results` row per Fact: attributable actual observation and actual environment, comparison record, exact authority identities and pass/fail verdict. Protected observations are digest-only/redacted according to the frozen sensitivity policy. Missing, extra, duplicate, stale, failed, authority-drifted or reused/indistinguishable rows fail the Assertion. Every blocker preserves its Source-item/method/required-capability lineage into a machine Claim proved on the exact capability-qualified target or a target-blocking External Confirmation. Authority Lock, Authority Revision and Final Gate remain the sole lifecycle and Final Gate source-recompiles/reruns the whole current snapshot. This Skill creates no Contract Draft, Outcome, Receipt, Check result or Gate.
+The same revised proposal, selected resources and all validated residual handoff files enter `long-task-workflow`'s Source-bound Contract Draft loop immediately. Every marked handoff is in `task.source_paths`; each Contract design target's frozen `source_paths` and Check `verification_inputs` equal its owning handoff plus every declared resource path and condition. Preflight hydrates one target at a time from its canonical manifest; Compile rejects missing, extra or duplicate targets and conflicting repeated residual shared rows while retaining only compact cross-file indexes. This adapter seam preserves the existing Contract, Authority, Outcome, deterministic fail-closed diagnostic precedence and Final Gate. Covered Source Items map through `source_claims` to the root conformance Assertion. Every verification method maps to an independently failing Assertion carrying its relevant Source Claims; each method × condition evidence cell carries exact handoff `fact_refs` plus canonical `fact_expectations` for subject/variation/property, sensitivity, expected located digest, comparator/parameters/tolerance/mask, Oracle and environment. Their exact union equals the target Fact set and all property-required Fact × method obligations. Current typed `design_method` evidence repeats the exact Fact set and supplies one `fact_results` row per Fact: attributable actual observation and actual environment, comparison record, exact authority identities and pass/fail verdict. Protected observations are digest-only/redacted according to the frozen sensitivity policy. Missing, extra, duplicate, stale, failed, authority-drifted or reused/indistinguishable rows fail the Assertion. Every blocker preserves its Source-item/method/required-capability lineage into a machine Claim proved on the exact capability-qualified target or a target-blocking External Confirmation. Authority Lock, Authority Revision and Final Gate remain the sole lifecycle and Final Gate source-recompiles/reruns the whole current snapshot. This Skill creates no Contract Draft, Outcome, Receipt, Check result or Gate.
 
 ## Forbidden inferences
 

package/dist/commands/design-resource.js

@@ -1,5 +1,6 @@
+import { publishDesignResourceHandoffBundle } from "../lib/design-resource-handoff-bundle.js";
 import { preflightDesignResourceHandoff } from "../lib/design-resource-handoff-validation.js";
-import { normalizeRepositoryFile } from "../lib/long-task-paths.js";
+import { normalizeRepositoryCwd, normalizeRepositoryFile, } from "../lib/long-task-paths.js";
 import { canonicalJson } from "../lib/strict-codec.js";
 export async function designResource(args) {
     const [subcommand = "help", ...rest] = args;
@@ -7,6 +8,10 @@ export async function designResource(args) {
         help();
         return;
     }
+    if (subcommand === "bundle") {
+        await bundle(rest);
+        return;
+    }
     if (subcommand !== "preflight")
         throw new Error(`Unknown design-resource subcommand: ${subcommand}`);
     const json = rest.includes("--json");
@@ -25,8 +30,63 @@ export async function designResource(args) {
     console.log(`Coverage: ${result.counts.subjects} subjects x 8 dimensions (${result.counts.coverage} grouped rows)`);
     console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
 }
+async function bundle(args) {
+    const positional = [];
+    const manifests = [];
+    let maxHandoffBytes = null;
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const item = args[index];
+        if (item === "--json") {
+            json = true;
+            continue;
+        }
+        if (item === "--manifest") {
+            const value = args[index + 1];
+            if (!value)
+                throw new Error("--manifest requires a path");
+            manifests.push(normalizeRepositoryFile(value, "design_resource_bundle_manifest"));
+            index += 1;
+            continue;
+        }
+        if (item === "--max-handoff-bytes") {
+            const value = args[index + 1];
+            if (!value)
+                throw new Error("--max-handoff-bytes requires an integer");
+            maxHandoffBytes = Number(value);
+            index += 1;
+            continue;
+        }
+        if (item.startsWith("--"))
+            throw new Error(`Unknown design-resource bundle option: ${item}`);
+        positional.push(item);
+    }
+    if (positional.length !== 2 ||
+        manifests.length === 0 ||
+        maxHandoffBytes === null)
+        throw new Error("usage: ty-context design-resource bundle <draft-dir> <new-output-dir> --manifest <facts.json> [--manifest <facts.json> ...] --max-handoff-bytes <bytes> [--json]");
+    const result = await publishDesignResourceHandoffBundle({
+        repository: process.cwd(),
+        draft_directory: normalizeRepositoryCwd(positional[0], "design_resource_bundle_draft_directory"),
+        output_directory: normalizeRepositoryCwd(positional[1], "design_resource_bundle_output_directory"),
+        manifest_paths: manifests,
+        max_handoff_bytes: maxHandoffBytes,
+    });
+    if (json) {
+        process.stdout.write(canonicalJson(result));
+        return;
+    }
+    console.log(`Design resource handoff bundle published: ${result.output_directory}`);
+    console.log(`Handoffs: ${result.handoffs.length}`);
+    console.log(`Targets: ${result.handoffs.map((item) => item.target_key).join(", ")}`);
+}
 function help() {
     console.log(`ty-context design-resource commands:
   preflight <handoff.md> [--json]
-                       Validate one selected implementation handoff`);
+                       Validate one selected implementation handoff
+  bundle <draft-dir> <new-output-dir> --manifest <facts.json> [...]
+         --max-handoff-bytes <bytes> [--json]
+                       Validate manifest-backed one-target handoffs and
+                       atomically publish the complete target set; the
+                       output parent directory must already exist`);
 }

package/dist/lib/design-resource-fact-manifest-validation.d.ts

@@ -1,3 +1,5 @@
 import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
 import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function loadAndValidateDesignResourceFactManifests(repository: string, parsed: ParsedDesignResourceHandoffV1): Promise<Map<string, DesignResourceObservableFactManifestV1>>;
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
+export declare function parseDesignResourceFactManifests(parsed: ParsedDesignResourceHandoffInputV1, contents: Map<string, Buffer>): Map<string, DesignResourceObservableFactManifestV1>;
+export declare function validateDesignResourceFactManifests(parsed: ParsedDesignResourceHandoffV1, contents: Map<string, Buffer>, manifests: Map<string, DesignResourceObservableFactManifestV1>, validateProjection: boolean): void;

package/dist/lib/design-resource-fact-manifest-validation.js

@@ -1,18 +1,9 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
 import { parseDesignResourceFactManifestJson } from "./design-resource-fact-manifest-shape.js";
 import { validateDesignResourceFactManifestUniverse } from "./design-resource-fact-manifest-universe.js";
 import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-export async function loadAndValidateDesignResourceFactManifests(repository, parsed) {
+export function parseDesignResourceFactManifests(parsed, contents) {
     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));
-    }
     const manifests = new Map();
-    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
     for (const target of parsed.handoff.targets) {
         const manifestRef = target.source_profile.fact_manifest_resource_ref;
         const manifestResource = resources.get(manifestRef);
@@ -32,13 +23,23 @@ export async function loadAndValidateDesignResourceFactManifests(repository, par
         if (manifest.target_key !== target.key ||
             manifest.scope_key !== parsed.handoff.scope.key)
             invalid("fact_manifest_identity_mismatch", `${target.key}:${manifest.scope_key}:${manifest.target_key}`);
-        validateDesignResourceFactManifestUniverse(manifest, parsed.handoff, target, resources, contents, sourceItems);
-        validateManifestProjection(parsed.handoff, target.key, manifest);
         manifests.set(target.key, manifest);
     }
     sameSet([...manifests.keys()], parsed.handoff.targets.map((target) => target.key), "fact_manifest_target_set_mismatch", "handoff");
     return manifests;
 }
+export function validateDesignResourceFactManifests(parsed, contents, manifests, validateProjection) {
+    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
+    const sourceItems = new Map(Object.entries(parsed.source_item_kinds));
+    for (const target of parsed.handoff.targets) {
+        const manifest = manifests.get(target.key);
+        if (!manifest)
+            invalid("fact_manifest_target_missing", target.key);
+        validateDesignResourceFactManifestUniverse(manifest, parsed.handoff, target, resources, contents, sourceItems);
+        if (validateProjection)
+            validateManifestProjection(parsed.handoff, target.key, manifest);
+    }
+}
 function validateManifestProjection(handoff, targetKey, manifest) {
     const target = handoff.targets.find((item) => item.key === targetKey);
     const targetConditions = new Set(target.condition_refs);
@@ -77,12 +78,16 @@ function validateManifestProjection(handoff, targetKey, manifest) {
     exactRows(handoff.acceptance_blockers.filter((row) => row.target_refs.includes(targetKey)), manifest.acceptance_blockers, "acceptance_blockers", targetKey);
 }
 function exactRows(handoffRows, manifestRows, collection, targetKey) {
-    const handoff = new Map(handoffRows.map((row) => [row.key, canonicalJson(row)]));
-    const manifest = new Map(manifestRows.map((row) => [row.key, canonicalJson(row)]));
-    sameSet([...handoff.keys()], [...manifest.keys()], `manifest_handoff_${collection}_set_mismatch`, targetKey);
-    for (const [key, value] of manifest)
-        if (handoff.get(key) !== value)
-            invalid(`manifest_handoff_${collection}_row_mismatch`, `${targetKey}:${key}`);
+    const handoff = new Map(handoffRows.map((row) => [row.key, row]));
+    if (handoff.size !== manifestRows.length)
+        invalid(`manifest_handoff_${collection}_set_mismatch`, `${targetKey}:count:${handoff.size}:${manifestRows.length}`);
+    for (const manifestRow of manifestRows) {
+        const handoffRow = handoff.get(manifestRow.key);
+        if (!handoffRow)
+            invalid(`manifest_handoff_${collection}_set_mismatch`, `${targetKey}:missing:${manifestRow.key}`);
+        if (canonicalJson(handoffRow) !== canonicalJson(manifestRow))
+            invalid(`manifest_handoff_${collection}_row_mismatch`, `${targetKey}:${manifestRow.key}`);
+    }
 }
 function canonicalJson(value) {
     if (Array.isArray(value))

package/dist/lib/design-resource-fact-universe-catalog.js

@@ -101,7 +101,7 @@ export function validateManifestFactCells(manifest, sourceItems, census) {
         actual.set(fingerprint, cell.key);
         validateFactCellDisposition(cell, coveredFacts);
     }
-    sameSet([...actual.keys()], expectedFactCellFingerprints(manifest), "manifest_expected_fact_cell_universe_mismatch", manifest.target_key);
+    assertExpectedFactCellFingerprints(manifest, actual);
     unique(coveredFacts, "manifest_fact_ref_reused_by_cells");
     sameSet(coveredFacts, manifest.facts.map((fact) => fact.key), "manifest_expected_canonical_fact_set_mismatch", manifest.target_key);
 }
@@ -134,18 +134,28 @@ function validateFactCellDisposition(cell, coveredFacts) {
         cell.disposition === "unavailable")
         invalid("manifest_fact_cell_unresolved", cell.key);
 }
-function expectedFactCellFingerprints(manifest) {
-    const expected = [];
+function assertExpectedFactCellFingerprints(manifest, actual) {
+    const variationsBySubject = new Map();
+    for (const variation of manifest.variations) {
+        const rows = variationsBySubject.get(variation.subject_ref) ?? [];
+        rows.push(variation.key);
+        variationsBySubject.set(variation.subject_ref, rows);
+    }
+    let expectedCount = 0;
     for (const subject of manifest.subjects)
         for (const condition of manifest.conditions)
-            for (const variation of manifest.variations.filter((item) => item.subject_ref === subject.key))
+            for (const variationRef of variationsBySubject.get(subject.key) ?? [])
                 for (const property of manifest.properties)
-                    expected.push(factCellFingerprint({
+                    if (!actual.has(factCellFingerprint({
                         subject_ref: subject.key,
                         target_ref: manifest.target_key,
                         condition_ref: condition.key,
-                        variation_ref: variation.key,
+                        variation_ref: variationRef,
                         property_ref: property.key,
-                    }));
-    return expected;
+                    })))
+                        invalid("manifest_expected_fact_cell_universe_mismatch", `${manifest.target_key}:missing:${subject.key}:${condition.key}:${variationRef}:${property.key}`);
+                    else
+                        expectedCount += 1;
+    if (actual.size !== expectedCount)
+        invalid("manifest_expected_fact_cell_universe_mismatch", `${manifest.target_key}:count:${actual.size}:${expectedCount}`);
 }

package/dist/lib/design-resource-fact-universe-helpers.js

@@ -1,11 +1,15 @@
+import { createHash } from "node:crypto";
 import { DESIGN_RESOURCE_STANDARD_CONDITION_AXES, } from "./design-resource-fact-manifest-types.js";
 import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-import { sha256Hex } from "./strict-codec.js";
 export function manifestIdentityDigest(rows) {
-    return sha256Hex(rows
-        .map((row) => stableJson(row))
-        .sort()
-        .join("\n"));
+    const hash = createHash("sha256");
+    const identities = rows.map((row) => stableJson(row)).sort();
+    for (let index = 0; index < identities.length; index += 1) {
+        if (index > 0)
+            hash.update("\n");
+        hash.update(identities[index]);
+    }
+    return hash.digest("hex");
 }
 export function manifestCollectionRows(manifest) {
     return new Map([

package/dist/lib/design-resource-handoff-bundle-draft.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
+import type { DesignResourceHandoffResourceV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
+type BundleFailure = (code: string, detail: string) => never;
+export interface StagedDesignResourceHandoffDraft {
+    bytes: Buffer;
+    parsed: ParsedDesignResourceHandoffInputV1;
+    target: DesignResourceHandoffTargetV1;
+    manifest_resource: DesignResourceHandoffResourceV1;
+}
+export declare function stageDesignResourceHandoffDraft(repository: string, draftDirectory: string, temporaryDirectory: string, entryName: string, maxBytes: number, fail: BundleFailure): Promise<StagedDesignResourceHandoffDraft>;
+export {};

package/dist/lib/design-resource-handoff-bundle-draft.js

@@ -0,0 +1,38 @@
+import { lstat, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
+import { repoRelative } from "./long-task-workspace.js";
+export async function stageDesignResourceHandoffDraft(repository, draftDirectory, temporaryDirectory, entryName, maxBytes, fail) {
+    const draftFile = path.join(draftDirectory, entryName);
+    const info = await lstat(draftFile);
+    if (typeof info.nlink === "number" && info.nlink > 1)
+        fail("draft_hardlink_not_allowed", entryName);
+    assertByteLimit(entryName, info.size, maxBytes, fail);
+    const bytes = await readFile(draftFile);
+    assertByteLimit(entryName, bytes.length, maxBytes, fail);
+    const content = bytes.toString("utf8");
+    if (!Buffer.from(content, "utf8").equals(bytes))
+        fail("handoff_utf8_invalid", entryName);
+    const stagedFile = path.join(temporaryDirectory, entryName);
+    await writeFile(stagedFile, bytes, { flag: "wx" });
+    const stagedPath = repoRelative(repository, stagedFile);
+    const parsed = parseDesignResourceHandoffMarkdown(stagedPath, content);
+    if (!("representation" in parsed.handoff))
+        fail("manifest_backed_representation_required", entryName);
+    if (parsed.handoff.targets.length !== 1)
+        fail("one_target_per_handoff_required", `${entryName}:${parsed.handoff.targets.length}`);
+    const target = parsed.handoff.targets[0];
+    const manifestResource = parsed.handoff.resources.find((resource) => resource.key === target.source_profile.fact_manifest_resource_ref);
+    if (!manifestResource)
+        fail("target_manifest_resource_missing", target.key);
+    return {
+        bytes,
+        parsed,
+        target,
+        manifest_resource: manifestResource,
+    };
+}
+function assertByteLimit(entryName, actual, maximum, fail) {
+    if (actual > maximum)
+        fail("handoff_byte_limit_exceeded", `${entryName}:${actual}:${maximum}`);
+}