@zixcel/projection-contracts 0.0.0-stage → 0.10.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE-PREVIOUS

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NuxtJP contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,5 @@
+
+projection-contracts
+Copyright 2026 HAT Inc.
+Licensed under the Apache License, Version 2.0; see LICENSE.
+Earlier permissions and attribution remain in accompanying LICENSE-* files.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# @zixcel/projection-contracts
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Validate and seal bounded, renderer-neutral Data and Scene snapshots from explicitly
+selected owner-visible source revisions. Deterministic lineage and publication
+fences keep presentation tied to the accepted source without owning its meaning.
+
+```sh
+npm install @zixcel/projection-contracts@0.10.0
+```
+
+```ts
+import { produce, scene, ProjectionSlot } from '@zixcel/projection-contracts'
+
+const source = { owner: 'example', ref: 'selected', revision: 'revision-1', kind: 'example' }
+const data = produce({
+  key: 'review', producer: { id: 'builtin', version: '0.10.0',
+    contract: 'projection/0.10.0', configuration: 'reviewed' },
+  sources: [source], focus: 'resources', purpose: 'review',
+  visibilityRef: 'owner-authorized', limits: {}
+}, [{ source, items: [], relations: [], unresolved: [], truncated: false }])
+const slot = new ProjectionSlot('review')
+const receipt = slot.publish(slot.begin(), data)
+const view = scene(data, { key: 'scene', focus: 'resources', purpose: 'review',
+  regions: [], actions: [] })
+console.log(receipt.revision, view.revision)
+```
+
+`@zixcel/projection-contracts/client` exposes browser-safe validation helpers.
+Node/browser hashing uses identical SHA-256 bytes; the dependency on
+`@zixcel/interaction/input` validates explicit interaction declarations.
+
+The producer owns authorization, visible data and exact source selection. Scene
+labels and regions do not grant permissions. `ProjectionSlot` is an in-memory,
+disposable fence: it does not promise durability across restart. Use
+`@zixcel/projection-runtime` for bounded execution and durable publication.
+
+## Development
+
+Run the repository workspace install, type checks and behavioral tests described
+in the root README. Public dependencies resolve from npm; no vendor archive or
+private registry is required. [License](LICENSE) · [Notices](NOTICE).
+
+## Release provenance
+
+Starting with 0.10.1, releases use GitHub Actions OIDC trusted publishing from `zixcel/projection-runtime` (`publish-npm.yml`), without a stored npm publishing token. The workflow verifies reviewed archive hashes and requires npm provenance metadata. Check the published version on npm and verify registry signatures and provenance with `npm audit signatures` in an installed consumer project. Package runtime behavior and API contracts are unchanged by this release.

package/contract.json

@@ -0,0 +1,26 @@
+{
+  "owner": "NuxtJP Projection Platform",
+  "version": "0.10.0",
+  "implementation": "src/index.mjs; pure producer and executable in-memory publication contract, no durable runtime or renderer",
+  "ProjectionSource": {"required": ["owner", "ref", "revision", "kind"], "revision": "opaque exact owner snapshot token; never read latest; owner must provide an accessible exact snapshot", "additionalProperties": false},
+  "ProjectionRequest": {"required": ["key", "producer", "sources", "focus", "purpose", "visibilityRef", "limits"], "producer": ["id", "version", "contract", "configuration"], "additionalProperties": false},
+  "DataProjection": {"required": ["contract", "kind", "key", "revision", "lineage", "data"], "data": ["items", "relations", "unresolved", "truncated", "omittedByPolicy"], "item": ["id", "semanticRef", "group", "value", "evidence", "provenance", "resolutionRefs", "visibility", "sourceRefs"], "meaning": "already adopted owner references only; no name/path/shape interpretation or value conflict resolution"},
+  "SceneProjection": {"base": "DataProjection", "extraData": ["focus", "purpose", "regions", "actions"], "region": ["id", "role", "itemIds"], "action": ["id", "targetOwner", "commandRef", "contextRefs", "sourceRefs", "label"], "roles": ["Primary", "Context", "Interpretation", "Evidence", "Provenance", "Resolution", "Inspector", "Actions", "Activity"], "lineage": "exact source tuple + producer/request + DataProjection key/revision + exact Scene configuration", "authority": "available action is not authorized; final command admission stays with its owner"},
+  "ProjectedInteraction": {"placement":"optional Scene action.interaction", "required":["ref","generation","inputContractRef","input"], "input":"owner-declared @zixcel/interaction InputDeclaration, unchanged; operation and contract references must equal the action binding", "authority":"descriptor only, never submitted values, source bindings or authorization; missing declaration means read-only/unavailable", "additionalProperties":false},
+  "ProjectionRevision": "pp: + SHA-256 of bounded canonical JSON contract/kind/key/exact lineage/data; minted by Projection Platform, never copied from source, Graph commit or delivery sequence",
+  "serialization": "plain JSON; keys lexically sorted, unordered sources/items/relations normalized, ordered Scene regions retained; finite safe integers, well-formed Unicode; no getters/toJSON/functions/prototypes; digest is content identity, not authenticity",
+  "stateLayers": {"ProjectionState": "server-derived Data/Scene snapshots and lineage", "PresentationState": "client scene selection, focus, selected item, expansion and navigation stack; separate from server ProjectionState", "RenderState": "renderer-local DOM/canvas/layout/animation/scroll; never serialized here"},
+  "grouping": "semantic group requires an exact owner semanticRef; structural source paths and presentation hints can group without becoming meaning; identical predicates group without merging or overwriting claim values",
+  "visibility": "input is owner-policy-filtered and carries visibilityRef; visible/redacted/omitted are owner decisions, not PP authorization. Redacted item value and semantic/evidence/provenance refs are removed. Owner must omit relations that would disclose hidden data. Source refs themselves must be safe to disclose.",
+  "bounds": {"sources":8,"items":256,"relations":512,"provenance":512,"unresolved":64,"regions":16,"actions":64,"snapshotBytes":524288,"inputBytes":2097152,"jsonDepth":16,"jsonNodes":32768},
+  "oversize": "typed ProjectionLimitExceeded, no silent truncation. Upstream truncated flag preserved. Large metadata+BULK payload is deferred to PP runtime; 512 KiB STATE limit unchanged.",
+  "rebuild": "readExact(ProjectionSource) must return exactly that snapshot; missing/reclaimed source yields ProjectionRebuildUnavailable, never latest substitution. Rebuild only from source owners, never previous cache.",
+  "retention": "rebuild guaranteed only while every exact source tuple member remains available under owner retention/in-flight claims. This pure slice adds no lease or retention policy. C4 Retained/InFlight external roots can protect owner objects; later runtime must acquire/release those through source owners before promising a retention window.",
+  "PendingProjectionRepair": {"fields": ["ticket", "request", "failure"], "rule": "exact source refs and original publication fence, no source body/cache as authority; source commit is not rolled back on projection failure"},
+  "publication": "one explicitly constructed in-memory slot per key, opaque CAS fence distinct from ProjectionRevision. Duplicate last accepted ticket is idempotent; older repair loses CAS after newer publication. Cache loss does not reset the fence. Durable CAS/scheduling/recovery stays PP1, no substitute Graph database here.",
+  "Crowsi": "recovery returns Snapshot bytes or exact NoChange with opaque ProjectionRevision; producer has no transport dependency. Peer ACK is bytes received, not semantic adoption/rendered/user saw it.",
+  "ProjectionDelta": {"status": "reserved contract only; not produced or accepted by this implementation", "fields": ["key", "baseProjectionRevision", "projectionRevision", "producerContract", "operations", "lineage"], "operations": "bounded owner-defined operations under exact producer contract; receiver validates exact base, target and lineage; never a Crowsi diff"},
+  "SSR": "serialize key/revision/exact lineage; adoptSnapshot checks the exact expected key/revision and closed payload/digest. No silent binding to latest. Source revision advancement requires an explicit owner recovery response.",
+  "outcomes": ["InvalidProjection", "InvalidSourceRevision", "SourceUnavailable", "ProjectionRebuildUnavailable", "ProjectionUnavailable", "ProjectionLimitExceeded", "StaleProjectionPublication"],
+  "forbidden": ["semantic or memory writer", "Grant issuer", "Invocation writer", "source restoration from cache", "HAT-supplied renderer code", "Vue/SFC/HTML fields", "DOM callbacks", "implicit provider refresh", "persistent session journal", "model scheduling"]
+}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@zixcel/projection-contracts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.10.1",
+  "description": "Renderer-independent bounded projection, lineage and Scene contracts",
+  "type": "module",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "src",
+    "contract.json",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "LICENSE-PREVIOUS"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.d.mts",
+      "import": "./src/index.mjs"
+    },
+    "./client": {
+      "types": "./src/client.d.mts",
+      "import": "./src/client.mjs"
+    }
+  },
+  "imports": {
+    "#hash": {
+      "browser": "./src/hash-browser.mjs",
+      "default": "./src/hash-node.mjs"
+    }
+  },
+  "dependencies": {
+    "ohash": "2.0.11",
+    "@zixcel/interaction": "0.10.1"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "typecheck": "tsc --noEmit --strict --module NodeNext --moduleResolution NodeNext --target ES2022 test/public-types.mts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zixcel/projection-runtime.git",
+    "directory": "packages/projection-contracts"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "types": "./src/index.d.mts",
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "@types/node": "24.12.0"
+  },
+  "packageManager": "pnpm@10.29.3"
+}

package/src/client.d.mts

@@ -0,0 +1,12 @@
+/** Browser-safe exact projection wire types; owner meaning remains external. */
+export type * from './types/snapshot.mjs';
+import type { DataProjection, SceneProjection } from './types/snapshot.mjs';
+export function validateSnapshot(value: unknown): DataProjection | SceneProjection;
+export function canonical(value: unknown, maximum?: number): string;
+export function copy<T>(value: T): T;
+export function frozen<T>(value: T): Readonly<T>;
+export function shape(value: unknown, required: string[], optional?: string[]): void;
+export function text(value: unknown, maximum?: number): string;
+export const roles: readonly import('./types/snapshot.mjs').RegionRole[];
+export const LIMITS: Readonly<import('./types/input.mjs').ProjectionLimits>;
+export class ProjectionError extends Error { readonly code: string; constructor(code: string) }

package/src/client.mjs

@@ -0,0 +1,3 @@
+// Shared validation, not a browser-specific schema or a canonical source reader.
+export {validateSnapshot} from './producer.mjs'
+export {canonical,copy,frozen,shape,text,roles,ProjectionError,LIMITS} from './contract.mjs'

package/src/contract.mjs

@@ -0,0 +1,59 @@
+import {sha256} from '#hash'
+const encoder=new TextEncoder()
+const byteLength=value=>encoder.encode(value).length
+export class ProjectionError extends Error {constructor(code){super(code);this.code=code}}
+export const fail=code=>{throw new ProjectionError(code)}
+export const LIMITS=Object.freeze({sources:8,items:256,relations:512,provenance:512,unresolved:64,regions:16,actions:64,snapshotBytes:524288})
+export function limits(input={}){
+  shape(input,[],Object.keys(LIMITS));const result={...LIMITS,...input}
+  for(const key in result)if(!Number.isSafeInteger(result[key])||result[key]<1||result[key]>LIMITS[key])fail('ProjectionLimitExceeded')
+  return Object.freeze(result)
+}
+export function shape(v,required,optional=[]){
+  if(!v||Object.getPrototypeOf(v)!==Object.prototype||required.some(k=>!Object.hasOwn(v,k)))fail('InvalidProjection')
+  for(const k of Object.getOwnPropertyNames(v)){
+    const d=Object.getOwnPropertyDescriptor(v,k)
+    if(!d.enumerable||d.get||d.set||(!required.includes(k)&&!optional.includes(k)))fail('InvalidProjection')
+  }
+  if(Object.getOwnPropertySymbols(v).length)fail('InvalidProjection')
+}
+export function text(v,max=512){if(typeof v!=='string'||!v.length||v.length>max||byteLength(v)>max||!v.isWellFormed()||/[\x00-\x1f\x7f]/u.test(v))fail('InvalidProjection');return v}
+export function list(v,max){if(!Array.isArray(v)||v.length>max)fail('ProjectionLimitExceeded');return v}
+export function refs(v,max=32){return list(v,max).map(x=>text(x))}
+// Bounded plain JSON only. No callbacks, toJSON, prototypes or renderer execution.
+export function canonical(value,maximum=2097152){
+  let bytes=0,nodes=0
+  const add=n=>{bytes+=n;if(bytes>maximum)fail('ProjectionLimitExceeded')}
+  function walk(v,depth){
+    if(++nodes>32768||depth>16)fail('ProjectionLimitExceeded')
+    if(v===null||typeof v==='boolean'){add(5);return v}
+    if(typeof v==='number'){if(!Number.isSafeInteger(v))fail('InvalidProjection');add(24);return v}
+    if(typeof v==='string'){if(v.length>maximum)fail('ProjectionLimitExceeded');if(!v.isWellFormed())fail('InvalidProjection');add(byteLength(v)+2);return v}
+    if(Array.isArray(v)){add(v.length+2);if(v.length>4096)fail('ProjectionLimitExceeded');return v.map(x=>walk(x,depth+1))}
+    if(!v||Object.getPrototypeOf(v)!==Object.prototype)fail('InvalidProjection')
+    const keys=Object.getOwnPropertyNames(v);if(keys.length>1024||Object.getOwnPropertySymbols(v).length)fail('ProjectionLimitExceeded')
+    const out={};add(keys.length+2)
+    for(const k of keys.sort()){
+      const d=Object.getOwnPropertyDescriptor(v,k)
+      if(!d.enumerable||d.get||d.set||['__proto__','constructor','prototype','toJSON'].includes(k))fail('InvalidProjection')
+      text(k,512);add(byteLength(k)+3);out[k]=walk(v[k],depth+1)
+    }
+    return out
+  }
+  const encoded=JSON.stringify(walk(value,0));if(byteLength(encoded)>maximum)fail('ProjectionLimitExceeded');return encoded
+}
+export const digest=value=>sha256(canonical(value))
+export function frozen(v){if(v&&typeof v==='object'){Object.values(v).forEach(frozen);Object.freeze(v)}return v}
+export function copy(v){return JSON.parse(canonical(v))}
+export function sourceRef(v){shape(v,['owner','ref','revision','kind']);for(const k of ['owner','ref','revision','kind'])text(v[k]);return copy(v)}
+export const sourceKey=v=>canonical(sourceRef(v))
+export function unique(values,key=x=>x){const ids=new Set();for(const v of values){const id=key(v);if(ids.has(id))fail('InvalidProjection');ids.add(id)}return values}
+export const roles=Object.freeze(['Primary','Context','Interpretation','Evidence','Provenance','Resolution','Inspector','Actions','Activity'])
+export function request(v){
+  canonical(v);shape(v,['key','producer','sources','focus','purpose','visibilityRef','limits'])
+  text(v.key);text(v.focus);text(v.purpose);text(v.visibilityRef)
+  shape(v.producer,['id','version','contract','configuration']);text(v.producer.id);text(v.producer.version);text(v.producer.contract);text(v.producer.configuration)
+  const l=limits(v.limits),sources=unique(list(v.sources,l.sources).map(sourceRef),s=>canonical([s.owner,s.ref])).sort((a,b)=>sourceKey(a)<sourceKey(b)?-1:1)
+  if(!sources.length)fail('SourceUnavailable')
+  return frozen({...copy(v),sources,limits:l})
+}

package/src/hash-browser.mjs

@@ -0,0 +1,5 @@
+// Same SHA-256 UTF-8 bytes and hexadecimal identity as the Node contract.
+// Reuse the already selected unjs primitive, never a second projection algorithm.
+import {digest} from 'ohash/crypto'
+export const sha256=value=>Array.from(atob(digest(value).replaceAll('-','+').replaceAll('_','/')+'='),
+  c=>c.charCodeAt(0).toString(16).padStart(2,'0')).join('')

package/src/hash-node.mjs

@@ -0,0 +1,2 @@
+import {createHash} from 'node:crypto'
+export const sha256=value=>createHash('sha256').update(value).digest('hex')

package/src/index.d.mts

@@ -0,0 +1,27 @@
+export { ProjectionError, LIMITS, canonical } from './client.mjs';
+export type * from './client.mjs';
+export type * from './types/input.mjs';
+import type { DataProjection, SceneProjection } from './client.mjs';
+import type { ProjectionRequest, ExactSource, SceneConfiguration, ReadExact } from './types/input.mjs';
+export type Snapshot = DataProjection | SceneProjection;
+export interface PublicationTicket { readonly key: string; readonly expected: string }
+export interface PublicationReceipt extends PublicationTicket { readonly publication: string; readonly revision: string }
+export interface PendingRepair { readonly ticket: PublicationTicket; readonly request: ProjectionRequest; readonly failure: 'ProjectionUnavailable' | 'ProjectionLimitExceeded' }
+/** Validate and deterministically seal explicitly selected owner-visible data. */
+export function produce(input: ProjectionRequest, exactSources: readonly ExactSource[]): DataProjection;
+export function scene(data: DataProjection, configuration: SceneConfiguration): SceneProjection;
+export function validateSnapshot(value: unknown): Snapshot;
+export function rebuild(input: ProjectionRequest, readExact: ReadExact): DataProjection;
+export function recovery(snapshot: Snapshot, receiverRevision: string | null):
+  { kind: 'NoChange'; revision: string } | { kind: 'Snapshot'; revision: string; payload: Uint8Array };
+export function adoptSnapshot(snapshot: Snapshot, expected: { key: string; revision: string }): Readonly<Snapshot>;
+/** Disposable in-memory publication fence; it does not survive process restart. */
+export class ProjectionSlot {
+  constructor(key: string);
+  begin(): Readonly<PublicationTicket>;
+  publish(ticket: PublicationTicket, snapshot: Snapshot): Readonly<PublicationReceipt>;
+  read(): Readonly<Snapshot> | null;
+  dropCache(): void;
+}
+export function pendingRepair(ticket: PublicationTicket, input: ProjectionRequest, code: PendingRepair['failure']): Readonly<PendingRepair>;
+export function repair(slot: ProjectionSlot, pending: PendingRepair, readExact: ReadExact): Readonly<PublicationReceipt>;

package/src/index.mjs

@@ -0,0 +1,3 @@
+export {ProjectionError,LIMITS,canonical} from './contract.mjs'
+export {produce,scene,validateSnapshot,rebuild,recovery,adoptSnapshot} from './producer.mjs'
+export {ProjectionSlot,pendingRepair,repair} from './publication.mjs'

package/src/producer.mjs

@@ -0,0 +1,180 @@
+// Hatter 2026: temporal presentation reads only explicit paths in exact visible items.
+import {canonical,copy,digest,fail,frozen,limits,list,refs,request,roles,shape,sourceKey,sourceRef,text,unique} from './contract.mjs'
+import {validateInputDeclaration} from '@zixcel/interaction/input'
+function item(v,source){
+  shape(v,['id','semanticRef','group','value','evidence','provenance','resolutionRefs','visibility'])
+  text(v.id);if(v.semanticRef!==null)text(v.semanticRef)
+  shape(v.group,['kind','ref']);if(!['semantic','structural','presentation'].includes(v.group.kind))fail('InvalidProjection');text(v.group.ref)
+  if(v.group.kind==='semantic'&&v.group.ref!==v.semanticRef)fail('InvalidProjection')
+  if(!['visible','redacted','omitted'].includes(v.visibility))fail('InvalidProjection')
+  refs(v.evidence);refs(v.provenance);refs(v.resolutionRefs)
+  if(v.visibility==='omitted')return null
+  if(v.visibility==='redacted')return {id:v.id,semanticRef:null,group:{kind:'presentation',ref:'redacted'},value:null,evidence:[],provenance:[],resolutionRefs:[],visibility:'redacted',sourceRefs:[source]}
+  return {...copy(v),sourceRefs:[source]}
+}
+function unresolved(v,source){
+  shape(v,['id','reason','evidence','contextRefs','actionRefs']);text(v.id);text(v.reason);refs(v.evidence);refs(v.contextRefs);refs(v.actionRefs)
+  return {...copy(v),sourceRefs:[source]}
+}
+function seal(kind,key,lineage,data,maximum){
+  const body={contract:'projection/0.10.0',kind,key,lineage,data}
+  const revision='pp:'+digest(body),snapshot={...body,revision}
+  canonical(snapshot,maximum);return frozen(snapshot)
+}
+export function produce(input,exactSources){
+  const r=request(input),l=r.limits
+  canonical(exactSources);list(exactSources,l.sources)
+  if(exactSources.length!==r.sources.length)fail('SourceUnavailable')
+  const sources=new Map()
+  for(const s of exactSources){
+    shape(s,['source','items','relations','unresolved','truncated']);sourceRef(s.source)
+    if(typeof s.truncated!=='boolean')fail('InvalidProjection')
+    const key=sourceKey(s.source);if(sources.has(key))fail('InvalidSourceRevision');sources.set(key,s)
+  }
+  const items=[],relations=[],unresolvedItems=[];let truncated=false,omitted=0
+  for(const ref of r.sources){
+    const s=sources.get(sourceKey(ref));if(!s)fail('InvalidSourceRevision')
+    for(const v of list(s.items,l.items)){const next=item(v,ref);if(next)items.push(next);else omitted++}
+    for(const v of list(s.unresolved,l.unresolved))unresolvedItems.push(unresolved(v,ref))
+    for(const v of list(s.relations,l.relations)){
+      shape(v,['id','from','to','relationRef']);Object.values(v).forEach(x=>text(x));relations.push({...copy(v),sourceRefs:[ref]})
+    }
+    truncated ||= s.truncated
+  }
+  list(items,l.items);list(relations,l.relations);list(unresolvedItems,l.unresolved)
+  unique([...items,...unresolvedItems],v=>v.id);unique(relations,v=>v.id)
+  const ids=new Set(items.filter(v=>v.visibility==='visible').map(v=>v.id))
+  // Owners must remove relationships to omitted/redacted data in their visibility view.
+  for(const v of relations)if(!ids.has(v.from)||!ids.has(v.to))fail('InvalidProjection')
+  const count=items.reduce((n,v)=>n+v.provenance.length,0)+unresolvedItems.reduce((n,v)=>n+v.evidence.length,0)
+  if(count>l.provenance)fail('ProjectionLimitExceeded')
+  for(const values of [items,relations,unresolvedItems])values.sort((a,b)=>a.id<b.id?-1:1)
+  return seal('Data',r.key,{sources:r.sources,producer:r.producer,request:r},
+    {items,relations,unresolved:unresolvedItems,truncated,omittedByPolicy:omitted},l.snapshotBytes)
+}
+export function validateSnapshot(v){
+  canonical(v,524288);shape(v,['contract','kind','key','lineage','data','revision'])
+  if(v.contract!=='projection/0.10.0'||!['Data','Scene'].includes(v.kind))fail('InvalidProjection')
+  const {revision,...body}=v;if(revision!=='pp:'+digest(body))fail('InvalidProjection')
+  // Wire objects originate from the closed producer contract. Re-run structure
+  // validation through its exact input contract; content hash alone is not enough.
+  shape(v.lineage,['sources','producer','request'],v.kind==='Scene'?['dataProjection','sceneConfiguration']:[])
+  const r=request(v.lineage.request),l=r.limits;text(v.key);canonical(v,l.snapshotBytes)
+  if(canonical(v.lineage.sources)!==canonical(v.lineage.request.sources)||canonical(v.lineage.producer)!==canonical(v.lineage.request.producer))fail('InvalidProjection')
+  const d=v.data
+  shape(d,['items','relations','unresolved','truncated','omittedByPolicy'],v.kind==='Scene'?['focus','purpose','regions','actions','temporal','presentation']:[])
+  if(typeof d.truncated!=='boolean'||!Number.isSafeInteger(d.omittedByPolicy)||d.omittedByPolicy<0||d.omittedByPolicy>l.sources*l.items)fail('InvalidProjection')
+  const known=new Set(r.sources.map(sourceKey))
+  const checkSource=x=>{list(x.sourceRefs,1);if(x.sourceRefs.length!==1||!known.has(sourceKey(x.sourceRefs[0])))fail('InvalidSourceRevision')}
+  for(const x of list(d.items,l.items)){
+    checkSource(x);const {sourceRefs,...body}=x
+    if(canonical(item(body,sourceRefs[0]))!==canonical(x))fail('InvalidProjection')
+  }
+  for(const x of list(d.unresolved,l.unresolved)){
+    checkSource(x);const {sourceRefs,...body}=x;unresolved(body,sourceRefs[0])
+  }
+  unique([...d.items,...d.unresolved],x=>x.id);unique(list(d.relations,l.relations),x=>x.id)
+  const ids=new Set(d.items.filter(x=>x.visibility==='visible').map(x=>x.id))
+  for(const x of d.relations){shape(x,['id','from','to','relationRef','sourceRefs']);checkSource(x)
+    for(const key of ['id','from','to','relationRef'])text(x[key]);if(!ids.has(x.from)||!ids.has(x.to))fail('InvalidProjection')}
+  if(d.items.reduce((n,x)=>n+x.provenance.length,0)+d.unresolved.reduce((n,x)=>n+x.evidence.length,0)>l.provenance)fail('ProjectionLimitExceeded')
+  if(v.kind==='Data'){if(v.key!==r.key)fail('InvalidProjection')}
+  else{
+    shape(v.lineage.dataProjection,['key','revision'])
+    const base=seal('Data',r.key,{sources:r.sources,producer:r.producer,request:r},
+      {items:d.items,relations:d.relations,unresolved:d.unresolved,truncated:d.truncated,omittedByPolicy:d.omittedByPolicy},l.snapshotBytes)
+    if(base.key!==v.lineage.dataProjection.key||base.revision!==v.lineage.dataProjection.revision)fail('InvalidProjection')
+    const rebuilt=scene(base,v.lineage.sceneConfiguration)
+    if(canonical(rebuilt)!==canonical(v))fail('InvalidProjection')
+  }
+  return v
+}
+export function scene(data,configuration){
+  validateSnapshot(data);if(data.kind!=='Data')fail('InvalidProjection')
+  canonical(configuration);shape(configuration,['key','focus','purpose','regions','actions'],['temporal','presentation'])
+  text(configuration.key);text(configuration.focus);text(configuration.purpose)
+  const l=limits(data.lineage.request.limits),ids=new Set([...data.data.items,...data.data.unresolved].map(x=>x.id))
+  const regions=unique(list(configuration.regions,l.regions).map(v=>{
+    shape(v,['id','role','itemIds']);text(v.id);if(!roles.includes(v.role))fail('InvalidProjection')
+    unique(refs(v.itemIds,l.items));if(v.itemIds.some(id=>!ids.has(id)))fail('InvalidProjection');return copy(v)
+  }),v=>v.id)
+  const actions=unique(list(configuration.actions,l.actions).map(v=>{
+    shape(v,['id','targetOwner','commandRef','contextRefs','sourceRefs','label'],['interaction'])
+    text(v.id);text(v.targetOwner);text(v.commandRef);text(v.label,1024);refs(v.contextRefs)
+    const expected=new Set(data.lineage.sources.map(sourceKey));list(v.sourceRefs,l.sources).forEach(s=>{if(!expected.has(sourceKey(s)))fail('InvalidSourceRevision')})
+    if(!v.sourceRefs.length)fail('InvalidSourceRevision')
+    if(v.interaction!==undefined){
+      const i=v.interaction
+      shape(i,['ref','generation','inputContractRef','input'])
+      text(i.ref);text(i.generation);text(i.inputContractRef)
+      if(validateInputDeclaration(i.input).length)fail('InvalidProjection')
+      if(i.input.action.contract_revision!==i.inputContractRef||i.input.action.operation_id!==v.commandRef)fail('InvalidProjection')
+    }
+    return copy(v)
+  }),v=>v.id)
+  const lineage={...copy(data.lineage),dataProjection:{key:data.key,revision:data.revision},sceneConfiguration:copy(configuration)}
+  const visibleValue=(itemId,valuePath)=>{
+    text(itemId);list(valuePath,16).forEach(key=>text(key,256))
+    const item=data.data.items.find(item=>item.id===itemId&&item.visibility==='visible')
+    if(!item)fail('InvalidProjection')
+    let value=item.value
+    for(const key of valuePath){if(value===null||typeof value!=='object'||!Object.hasOwn(value,key))fail('InvalidProjection');value=value[key]}
+    return value
+  }
+  let presentation
+  if(configuration.presentation!==undefined)presentation=unique(list(configuration.presentation,l.items).map(binding=>{
+    shape(binding,['itemId'],['titlePath','title','summaryPath','fields','symbol']);visibleValue(binding.itemId,[])
+    if(Object.hasOwn(binding,'title')===Object.hasOwn(binding,'titlePath'))fail('InvalidProjection')
+    const title=Object.hasOwn(binding,'titlePath')?visibleValue(binding.itemId,binding.titlePath):binding.title;text(title,1024)
+    // Presentation labels never become semantics or permission. Field values are exact visible source paths.
+    const fields=binding.fields===undefined?undefined:list(binding.fields,16).map(field=>{
+      shape(field,['label','valuePath']);text(field.label,256)
+      const value=visibleValue(binding.itemId,field.valuePath)
+      if(value!==null&&!['string','boolean','number'].includes(typeof value))fail('InvalidProjection')
+      if(typeof value==='string'&&value.length>4096)fail('ProjectionLimitExceeded')
+      return {label:field.label,value}
+    })
+    if(binding.symbol!==undefined)text(binding.symbol,64)
+    const summary=binding.summaryPath===undefined?undefined:visibleValue(binding.itemId,binding.summaryPath)
+    if(summary!==undefined)text(summary,2048)
+    return {itemId:binding.itemId,title,...(summary===undefined?{}:{summary}),...(fields===undefined?{}:{fields}),...(binding.symbol===undefined?{}:{symbol:binding.symbol})}
+  }),item=>item.itemId)
+  let temporal
+  if(configuration.temporal!==undefined){
+    const declaration=configuration.temporal;shape(declaration,['label','items']);text(declaration.label,256)
+    const items=unique(list(declaration.items,l.items).map(binding=>{
+      shape(binding,['itemId','valuePath','format']);text(binding.itemId);list(binding.valuePath,16).forEach(key=>text(key,256))
+      if(!['utcInstant','unixMilliseconds'].includes(binding.format))fail('InvalidProjection')
+      let at=visibleValue(binding.itemId,binding.valuePath)
+      if(binding.format==='unixMilliseconds'){
+        if(!Number.isSafeInteger(at)||at<0||at>253402300799999)fail('InvalidProjection')
+        at=new Date(at).toISOString()
+      }
+      // Declared encodings only: no field-name heuristic, coercion or inferred date.
+      if(typeof at!=='string'||!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(at)||!Number.isFinite(Date.parse(at))||new Date(at).toISOString()!==at)fail('InvalidProjection')
+      return {itemId:binding.itemId,at}
+    }),item=>item.itemId).sort((a,b)=>a.at===b.at?(a.itemId<b.itemId?-1:1):(a.at<b.at?-1:1))
+    temporal={label:declaration.label,items}
+  }
+  return seal('Scene',configuration.key,lineage,{...copy(data.data),focus:configuration.focus,purpose:configuration.purpose,regions,actions,...(temporal?{temporal}:{}),...(presentation?{presentation}:{})},l.snapshotBytes)
+}
+export function rebuild(input,readExact){
+  const r=request(input)
+  const sources=r.sources.map(ref=>{
+    let value;try{value=readExact(ref)}catch{fail('ProjectionRebuildUnavailable')}
+    if(value?.then){Promise.resolve(value).catch(()=>{});fail('ProjectionRebuildUnavailable')}
+    if(value==null)fail('ProjectionRebuildUnavailable');return value
+  })
+  return produce(r,sources)
+}
+export function recovery(snapshot,receiverRevision){
+  validateSnapshot(snapshot)
+  if(receiverRevision!==null)text(receiverRevision)
+  if(receiverRevision===snapshot.revision)return {kind:'NoChange',revision:snapshot.revision}
+  return {kind:'Snapshot',revision:snapshot.revision,payload:Buffer.from(canonical(snapshot,524288))}
+}
+export function adoptSnapshot(snapshot,expected){
+  shape(expected,['key','revision']);text(expected.key);text(expected.revision);validateSnapshot(snapshot)
+  if(snapshot.key!==expected.key||snapshot.revision!==expected.revision)fail('InvalidSourceRevision')
+  return frozen(copy(snapshot))
+}

package/src/publication.mjs

@@ -0,0 +1,36 @@
+import {randomUUID} from 'node:crypto'
+import {copy,fail,frozen,request,shape,text} from './contract.mjs'
+import {rebuild,validateSnapshot} from './producer.mjs'
+// Executable in-memory publication contract, not a durable scheduler or Graph CAS.
+// Head fencing survives disposable cache loss within this slot. Restart requires
+// a fresh exact owner rebuild; no durable publication guarantee is claimed here.
+export class ProjectionSlot {
+  #key;#fence=randomUUID();#snapshot=null;#receipt=null
+  constructor(key){this.#key=text(key)}
+  begin(){return frozen({key:this.#key,expected:this.#fence})}
+  publish(ticket,snapshot){
+    shape(ticket,['key','expected']);validateSnapshot(snapshot)
+    if(ticket.key!==this.#key||snapshot.key!==this.#key)fail('InvalidProjection')
+    if(this.#receipt?.expected===ticket.expected&&this.#receipt.revision===snapshot.revision){
+      if(!this.#snapshot)this.#snapshot=frozen(copy(snapshot))
+      return this.#receipt
+    }
+    if(ticket.expected!==this.#fence)fail('StaleProjectionPublication')
+    this.#snapshot=frozen(copy(snapshot));this.#fence=randomUUID()
+    this.#receipt=frozen({key:this.#key,expected:ticket.expected,publication:this.#fence,revision:snapshot.revision})
+    return this.#receipt
+  }
+  read(){if(!this.#snapshot)return null;try{return frozen(copy(validateSnapshot(this.#snapshot)))}catch{fail('ProjectionUnavailable')}}
+  dropCache(){this.#snapshot=null}
+}
+export function pendingRepair(ticket,input,code){
+  shape(ticket,['key','expected']);text(ticket.key);text(ticket.expected)
+  if(!['ProjectionUnavailable','ProjectionLimitExceeded'].includes(code))fail('InvalidProjection')
+  const r=request(input);if(r.key!==ticket.key)fail('InvalidProjection')
+  return frozen({ticket:copy(ticket),request:r,failure:code})
+}
+export function repair(slot,pending,readExact){
+  shape(pending,['ticket','request','failure'])
+  const p=pendingRepair(pending.ticket,pending.request,pending.failure)
+  return slot.publish(p.ticket,rebuild(p.request,readExact))
+}

package/src/types/input.d.mts

@@ -0,0 +1,24 @@
+import type { Item, SourceRef, Unresolved, Relation, Region, Action } from './snapshot.mjs';
+/** Exact producer identity: no request-provided code or implicit latest revision. */
+export interface ProducerIdentity { readonly id: string; readonly version: string; readonly contract: string; readonly configuration: string }
+export interface ProjectionLimits { sources: number; items: number; relations: number; provenance: number; unresolved: number; regions: number; actions: number; snapshotBytes: number }
+export interface ProjectionRequest {
+  readonly key: string; readonly producer: ProducerIdentity; readonly sources: readonly SourceRef[];
+  readonly focus: string; readonly purpose: string; readonly visibilityRef: string; readonly limits: Partial<ProjectionLimits>;
+}
+export interface ExactSource {
+  readonly source: SourceRef; readonly items: readonly (Omit<Item, 'sourceRefs' | 'visibility'> & { readonly visibility: 'visible' | 'redacted' | 'omitted' })[];
+  readonly unresolved: readonly Omit<Unresolved, 'sourceRefs'>[];
+  readonly relations: readonly Omit<Relation, 'sourceRefs'>[]; readonly truncated: boolean;
+}
+export interface SceneConfiguration {
+  readonly key: string; readonly focus: string; readonly purpose: string;
+  readonly regions: readonly Region[]; readonly actions: readonly Action[];
+  readonly temporal?: { readonly label: string; readonly items: readonly { readonly itemId: string; readonly valuePath: readonly string[]; readonly format: 'utcInstant' | 'unixMilliseconds' }[] };
+  readonly presentation?: readonly {
+    readonly itemId: string; readonly title?: string; readonly titlePath?: readonly string[];
+    readonly summaryPath?: readonly string[]; readonly symbol?: string;
+    readonly fields?: readonly { readonly label: string; readonly valuePath: readonly string[] }[];
+  }[];
+}
+export type ReadExact = (source: SourceRef) => ExactSource | null;

package/src/types/snapshot.d.mts

@@ -0,0 +1,43 @@
+import type { InputDeclaration } from '@zixcel/interaction/input';
+import type { ProducerIdentity, ProjectionRequest, SceneConfiguration } from './input.mjs';
+export type Json = null | boolean | number | string | readonly Json[] | { readonly [key: string]: Json };
+export interface SourceRef { readonly owner: string; readonly ref: string; readonly revision: string; readonly kind: string }
+export interface Item {
+  readonly id: string; readonly semanticRef: string | null;
+  readonly group: { readonly kind: 'semantic' | 'structural' | 'presentation'; readonly ref: string };
+  readonly value: Json; readonly evidence: readonly string[]; readonly provenance: readonly string[];
+  readonly resolutionRefs: readonly string[]; readonly visibility: 'visible' | 'redacted'; readonly sourceRefs: readonly SourceRef[];
+}
+export interface Unresolved {
+  readonly id: string; readonly reason: string; readonly evidence: readonly string[];
+  readonly contextRefs: readonly string[]; readonly actionRefs: readonly string[]; readonly sourceRefs: readonly SourceRef[];
+}
+export type RegionRole = 'Primary' | 'Context' | 'Interpretation' | 'Evidence' | 'Provenance' | 'Resolution' | 'Inspector' | 'Actions' | 'Activity';
+export interface Region { readonly id: string; readonly role: RegionRole; readonly itemIds: readonly string[] }
+export interface ProjectedInteraction {
+  readonly ref: string; readonly generation: string; readonly inputContractRef: string; readonly input: InputDeclaration;
+}
+export interface Action {
+  readonly id: string; readonly targetOwner: string; readonly commandRef: string; readonly label: string;
+  readonly contextRefs: readonly string[]; readonly sourceRefs: readonly SourceRef[]; readonly interaction?: ProjectedInteraction;
+}
+export interface Relation { readonly id: string; readonly from: string; readonly to: string; readonly relationRef: string; readonly sourceRefs: readonly SourceRef[] }
+export interface SourceLineage { readonly sources: readonly SourceRef[]; readonly producer: ProducerIdentity; readonly request: ProjectionRequest }
+export interface ProjectionIdentity { readonly key: string; readonly revision: string; readonly lineage: SourceLineage }
+export interface ProjectionData {
+  readonly items: readonly Item[]; readonly unresolved: readonly Unresolved[]; readonly relations: readonly Relation[];
+  readonly truncated: boolean; readonly omittedByPolicy: number;
+}
+export interface DataProjection extends ProjectionIdentity { readonly contract: 'projection/0.10.0'; readonly kind: 'Data'; readonly data: ProjectionData }
+export interface SceneProjection extends ProjectionIdentity {
+  readonly contract: 'projection/0.10.0'; readonly kind: 'Scene';
+  readonly lineage: SourceLineage & { readonly dataProjection: { readonly key: string; readonly revision: string }; readonly sceneConfiguration: SceneConfiguration };
+  readonly data: ProjectionData & {
+    readonly regions: readonly Region[]; readonly actions: readonly Action[]; readonly focus: string; readonly purpose: string;
+    readonly temporal?: { readonly label: string; readonly items: readonly { readonly itemId: string; readonly at: string }[] };
+    readonly presentation?: readonly {
+      readonly itemId: string; readonly title: string; readonly summary?: string; readonly symbol?: string;
+      readonly fields?: readonly { readonly label: string; readonly value: string | number | boolean | null }[];
+    }[];
+  };
+}