@zixcel/projection-client 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-client
+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,35 @@
-# Temporary Holding Version
+# @zixcel/projection-client
 
-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.
+Adopt a validated display snapshot and keep updates tied to the correct revision.
+
+## What you can do
+
+- Reject stale or mismatched snapshots.
+- Track navigation and interaction state across accepted updates.
+
+## Current scope
+
+The host supplies transport and trusted rendering. The client does not invent actions or canonical application state.
+
+Package distribution is not activated by this documentation. Use the checked-in source and the declared dependency versions; published availability must be verified separately.
+
+## Getting started
+
+The manifest currently requires locally supplied package archives: `@zixcel/projection-contracts`. These archives are excluded from Git. Obtain the exact approved dependency artifacts before installing; a fresh clone alone is not sufficient. Registry distribution remains pending.
+
+Use the package manager matching the checked-in lockfile and the Node.js version declared in `package.json` or the development configuration. Run from this repository:
+
+```sh
+pnpm install --frozen-lockfile
+pnpm test
+```
+
+## Documentation and source
+
+[Usage guide](docs/getting-started.md)
+
+[Implementation and public interfaces](src) · [Verification cases](test) · [Contributing](CONTRIBUTING.md) · [Security reporting](SECURITY.md) · [License](LICENSE) · [Attribution 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/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@zixcel/projection-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.10.1",
+  "type": "module",
+  "license": "Apache-2.0",
+  "description": "Bounded renderer-independent projection adoption and presentation runtime",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "LICENSE-PREVIOUS"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.d.mts",
+      "import": "./src/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@zixcel/projection-contracts": "0.10.1"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zixcel/projection-runtime.git",
+    "directory": "packages/projection-client"
+  }
+}

package/src/index.d.mts

@@ -0,0 +1,30 @@
+// Hatter downstream 2026: relations retain the canonical owner shape.
+import type {SceneProjection,ProjectionIdentity,Action,Item,Unresolved,Relation,Region} from '@zixcel/projection-contracts/client'
+export type {SceneProjection,ProjectionIdentity} from '@zixcel/projection-contracts/client'
+export interface Camera {readonly x:number;readonly y:number;readonly z:number}
+export type DisplayBinding=NonNullable<SceneProjection['data']['presentation']>[number]
+export type TemporalPlan=NonNullable<SceneProjection['data']['temporal']>&{readonly cursor:string|null}
+export type ViewMode='spatial'|'structured'
+export interface PresentationState {readonly activeScene:string|null;readonly focus:string|null;readonly selectedItems:readonly string[];readonly expandedItems:readonly string[];readonly activeRegion:string|null;readonly navigation:readonly string[];readonly navigationIndex:number;readonly inspector:string|null;readonly loading:boolean;readonly viewMode:ViewMode;readonly camera:Camera;readonly timeCursor:string|null}
+export interface ActionHandle {readonly projectionKey:string;readonly projectionRevision:string;readonly sceneId:string;readonly actionId:string}
+export interface SceneCommandIntent extends ActionHandle {readonly ownerCommandDescriptor:Action}
+export type AdoptionContext={kind:'hydrate',expected:ProjectionIdentity}|{kind:'current',expectedCurrent:string|null}
+export interface RenderItem {readonly id:string;readonly content:Item|Unresolved;readonly focused:boolean;readonly selected:boolean;readonly expanded:boolean;readonly related:boolean;readonly display:DisplayBinding|null}
+export interface RenderPlan {readonly projectionKey:string;readonly projectionRevision:string;readonly sceneId:string;readonly purpose:string;readonly viewMode:ViewMode;readonly camera:Camera;readonly temporal:TemporalPlan|null;readonly relations:readonly (Relation & {readonly active:boolean})[];readonly regions:readonly (Region & {readonly items:readonly RenderItem[]})[];readonly actions:readonly {descriptor:Action;handle:ActionHandle}[];readonly inspector:Item|Unresolved|null;readonly unplaced:readonly RenderItem[];readonly empty:boolean;readonly truncated:boolean;readonly omittedByPolicy:number}
+export function projectionIdentity(snapshot:SceneProjection):ProjectionIdentity
+export function renderPlan(projection:SceneProjection,presentation:PresentationState,capabilities?:{roles:readonly string[]}):RenderPlan
+export class ClientProjectionRuntime {
+  readonly projection:SceneProjection|null
+  readonly presentation:PresentationState
+  current(key:string):SceneProjection|null
+  adopt(snapshot:unknown,context:AdoptionContext):SceneProjection
+  input(input:unknown,context:{expectedCurrent:string|null}):SceneProjection
+  present(change:Partial<Pick<PresentationState,'focus'|'selectedItems'|'expandedItems'|'activeRegion'|'inspector'|'loading'|'viewMode'|'camera'|'timeCursor'>>):PresentationState
+  navigate(key:string):PresentationState
+  back():PresentationState
+  forward():PresentationState
+  action(id:string):ActionHandle
+  intent(handle:unknown):SceneCommandIntent
+  inspect():{keys:number;snapshots:number;closed:boolean}
+  close():void
+}

package/src/index.mjs

@@ -0,0 +1,138 @@
+// Hatter downstream 2026: one exact Scene, presentation-only view and relation emphasis.
+import {validateSnapshot,canonical,copy,frozen,shape,text,roles,ProjectionError} from '@zixcel/projection-contracts/client'
+
+const fail=code=>{throw new ProjectionError(code)}
+const check=(value,code)=>{if(!value)fail(code)}
+const empty=()=>({activeScene:null,focus:null,selectedItems:[],expandedItems:[],activeRegion:null,
+  navigation:[],navigationIndex:-1,inspector:null,loading:false,viewMode:'spatial',camera:{x:0,y:0,z:1},timeCursor:null})
+export const projectionIdentity=s=>frozen(copy({key:s.key,revision:s.revision,lineage:s.lineage}))
+function sceneSnapshot(snapshot){validateSnapshot(snapshot);check(snapshot.kind==='Scene','SceneUnavailable');return frozen(copy(snapshot))}
+function targets(snapshot){return new Set([...snapshot.data.items,...snapshot.data.unresolved].map(i=>i.id))}
+function rebase(previous,snapshot){
+  const ids=targets(snapshot),regions=new Set(snapshot.data.regions.map(r=>r.id))
+  return frozen({...previous,activeScene:snapshot.key,focus:ids.has(previous.focus)?previous.focus:null,
+    selectedItems:previous.selectedItems.filter(id=>ids.has(id)),expandedItems:previous.expandedItems.filter(id=>ids.has(id)),
+    activeRegion:regions.has(previous.activeRegion)?previous.activeRegion:null,inspector:ids.has(previous.inspector)?previous.inspector:null,
+    timeCursor:snapshot.data.temporal?.items.some(item=>item.itemId===previous.timeCursor)?previous.timeCursor:null})
+}
+
+export class ClientProjectionRuntime {
+  #cache=new Map();#presentation=frozen(empty());#closed=false
+  get projection(){return this.#cache.get(this.#presentation.activeScene)?.at(-1)??null}
+  get presentation(){return this.#presentation}
+  #open(){check(!this.#closed,'ClientRuntimeClosed')}
+  current(key){this.#open();return this.#cache.get(key)?.at(-1)??null}
+  adopt(snapshot,context){
+    this.#open();shape(context,['kind'],['expected','expectedCurrent'])
+    const next=sceneSnapshot(snapshot),old=this.current(next.key)
+    if(context.kind==='hydrate'){
+      check(canonical(projectionIdentity(next))===canonical(context.expected),'HydrationProjectionMismatch')
+      check(!old||old.revision===next.revision,'HydrationProjectionMismatch')
+    }else{
+      check(context.kind==='current'&&Object.hasOwn(context,'expectedCurrent'),'ProjectionAdoptionError')
+      check((old?.revision??null)===context.expectedCurrent,'StaleProjectionDelivery')
+    }
+    if(!old&&this.#cache.size===8){
+      const evict=[...this.#cache.keys()].find(k=>k!==this.#presentation.activeScene)
+      this.#cache.delete(evict)
+    }
+    const versions=this.#cache.get(next.key)??[]
+    const retained=versions.filter(v=>v.revision!==next.revision).slice(-1)
+    this.#cache.delete(next.key);this.#cache.set(next.key,[...retained,next])
+    if(this.#presentation.activeScene===next.key)this.#presentation=rebase(this.#presentation,next)
+    else if(this.#presentation.activeScene===null)this.navigate(next.key)
+    return next
+  }
+  input(input,context){
+    this.#open();shape(context,['expectedCurrent']);shape(input,['kind','revision'],input?.kind==='Snapshot'?['snapshot']:[]);text(input.revision)
+    if(input.kind==='Snapshot'){
+      check(input.snapshot?.revision===input.revision,'ProjectionAdoptionError')
+      return this.adopt(input.snapshot,{kind:'current',expectedCurrent:context.expectedCurrent})
+    }
+    check(input.kind==='NoChange','ProjectionAdoptionError')
+    check(this.projection?.revision===input.revision&&input.revision===context.expectedCurrent,'StaleProjectionDelivery')
+    return this.projection
+  }
+  present(change){
+    this.#open();check(this.projection,'SceneUnavailable')
+    shape(change,[],['focus','selectedItems','expandedItems','activeRegion','inspector','loading','viewMode','camera','timeCursor'])
+    const ids=targets(this.projection),regions=new Set(this.projection.data.regions.map(r=>r.id))
+    for(const key of ['selectedItems','expandedItems'])if(Object.hasOwn(change,key)){
+      check(Array.isArray(change[key])&&change[key].length<=256,'PresentationLimitExceeded')
+      check(new Set(change[key]).size===change[key].length&&change[key].every(id=>ids.has(id)),'InvalidPresentationTarget')
+    }
+    for(const key of ['focus','inspector'])if(Object.hasOwn(change,key))check(change[key]===null||ids.has(change[key]),'InvalidPresentationTarget')
+    if(Object.hasOwn(change,'activeRegion'))check(change.activeRegion===null||regions.has(change.activeRegion),'InvalidPresentationTarget')
+    if(Object.hasOwn(change,'loading'))check(typeof change.loading==='boolean','InvalidPresentationTarget')
+    if(Object.hasOwn(change,'viewMode'))check(['spatial','structured'].includes(change.viewMode),'InvalidPresentationTarget')
+    if(Object.hasOwn(change,'camera')){
+      shape(change.camera,['x','y','z'])
+      for(const key of ['x','y','z'])check(Number.isFinite(change.camera[key])&&change.camera[key]>=(key==='z'?.65:-1)&&change.camera[key]<=(key==='z'?1.5:1),'InvalidPresentationTarget')
+    }
+    if(Object.hasOwn(change,'timeCursor'))check(change.timeCursor===null||this.projection.data.temporal?.items.some(item=>item.itemId===change.timeCursor),'InvalidPresentationTarget')
+    // Camera is bounded local presentation, not integer-only canonical source data.
+    const {camera,...rest}=change
+    this.#presentation=frozen({...this.#presentation,...copy(rest),...(camera?{camera:{...camera}}:{})})
+    return this.#presentation
+  }
+  navigate(key){
+    this.#open();const next=this.current(key);check(next,'SceneUnavailable')
+    if(this.#presentation.activeScene===key)return this.#presentation
+    const navigation=[...this.#presentation.navigation.slice(0,this.#presentation.navigationIndex+1),key].slice(-64)
+    this.#presentation=rebase({...empty(),navigation,navigationIndex:navigation.length-1},next)
+    return this.#presentation
+  }
+  #move(delta){
+    this.#open();const index=this.#presentation.navigationIndex+delta
+    if(index<0||index>=this.#presentation.navigation.length)return this.#presentation
+    const next=this.current(this.#presentation.navigation[index]);check(next,'SceneUnavailable')
+    this.#presentation=rebase({...empty(),navigation:this.#presentation.navigation,navigationIndex:index},next)
+    return this.#presentation
+  }
+  back(){return this.#move(-1)}
+  forward(){return this.#move(1)}
+  action(id){
+    this.#open();check(this.projection?.data.actions.some(a=>a.id===id),'StaleSceneAction')
+    return frozen({projectionKey:this.projection.key,projectionRevision:this.projection.revision,sceneId:this.projection.key,actionId:id})
+  }
+  intent(handle){
+    this.#open();shape(handle,['projectionKey','projectionRevision','sceneId','actionId'])
+    const p=this.projection
+    check(p&&handle.projectionKey===p.key&&handle.sceneId===p.key&&handle.projectionRevision===p.revision,'StaleSceneAction')
+    const action=p.data.actions.find(a=>a.id===handle.actionId);check(action,'StaleSceneAction')
+    return frozen({...copy(handle),ownerCommandDescriptor:action})
+  }
+  inspect(){return {keys:this.#cache.size,snapshots:[...this.#cache.values()].reduce((n,v)=>n+v.length,0),closed:this.#closed}}
+  close(){this.#closed=true;this.#cache.clear();this.#presentation=frozen(empty())}
+}
+
+export function renderPlan(projection,presentation,capabilities={roles}){
+  check(projection&&presentation.activeScene===projection.key,'RenderPlanError')
+  const values=new Map([...projection.data.items,...projection.data.unresolved].map(v=>[v.id,v]))
+  const selected=new Set(presentation.selectedItems),expanded=new Set(presentation.expandedItems)
+  const active=id=>selected.has(id)||presentation.focus===id,related=new Set()
+  const relations=projection.data.relations.map(relation=>{
+    const highlighted=active(relation.from)||active(relation.to)
+    if(highlighted){related.add(relation.from);related.add(relation.to)}
+    return {...relation,active:highlighted}
+  })
+  const item=content=>({id:content.id,content,focused:presentation.focus===content.id,
+    selected:selected.has(content.id),expanded:expanded.has(content.id),related:related.has(content.id),
+    display:projection.data.presentation?.find(binding=>binding.itemId===content.id)??null})
+  const regions=projection.data.regions.map(region=>{
+    check(capabilities.roles.includes(region.role),'UnsupportedRenderer')
+    return {...region,items:region.itemIds.map(id=>{
+      check(values.has(id),'RenderPlanError')
+      return item(values.get(id))
+    })}
+  })
+  return frozen({projectionKey:projection.key,projectionRevision:projection.revision,sceneId:projection.key,
+    purpose:projection.data.purpose,viewMode:presentation.viewMode,camera:presentation.camera,
+    temporal:projection.data.temporal?{...projection.data.temporal,cursor:presentation.timeCursor}:null,
+    regions,relations,actions:projection.data.actions.map(action=>({descriptor:action,
+      handle:{projectionKey:projection.key,projectionRevision:projection.revision,sceneId:projection.key,actionId:action.id}})),
+    inspector:presentation.inspector===null?null:values.get(presentation.inspector)??null,
+    unplaced:[...values.values()].filter(v=>!projection.data.regions.some(r=>r.itemIds.includes(v.id)))
+      .map(item),
+    empty:values.size===0,truncated:projection.data.truncated,omittedByPolicy:projection.data.omittedByPolicy})
+}