Writer.setSceneModel ​

ts

setSceneModel(model: DeepReadonly<SceneModel>, options?: RecordedOptions<C> & SceneModelOptions): Promise<Report>;

ts

import type { IConfigurator, JsonPatchOp, JsonValue, Session } from '@holostep-configurators/runtime-client/contract';
declare const session: Session;
declare const signal: AbortSignal;
// A store sync, both ways. The store's document stays the source of truth.
declare const store: { replace(doc: IConfigurator): void };
declare function rootFor(doc: IConfigurator): string;
// applies a commit's scene-model ops to `doc` by nodeId: each node's position, rotation,
// scale and enabled and each group's defaultNodeId (a field op, or a node an undo adds back)
declare function mergeChanges(doc: IConfigurator, patch: readonly JsonPatchOp[]): IConfigurator;
// what the store owns beyond placement (an instance list, selections); at most 256 KB
declare function structureOf(doc: IConfigurator): JsonValue;
declare function withStructure(doc: IConfigurator, structure: JsonValue): IConfigurator;
declare function reportSyncError(error: unknown): void;
const SYNC = 'store-sync';
let current: IConfigurator | null = null;        // the store's latest document
let echoed: IConfigurator | null = null;         // the document this code pushed into the store
let edits = 0;                                   // store edits so far, echoes excluded
let editsAtUndo = 0;                             // `edits` when the shopper last pressed undo

// Runtime → store. Skip our own sync by `origin`, and merge only what each commit changed
// (its `patch`), never its whole model: a commit's payload can predate the store's latest
// document (a write called before that sync can commit after the sync's call, `Cause.seq`),
// and merging a whole snapshot would put that document's newer placement back (spec section
// 6.11, rule 6). The delta keeps both: a shopper's pick made while a sync was queued returns
// to the store, and the store's own newer edits stay (the runtime's model has no key
// material: never save it). An undo or redo can add or remove nodes, which placement can't
// carry: rebuild the store's structure from the checkpoint it restored first. A store edit
// made after undo was pressed owns the future: its queued sync commits after the undo and
// re-projects the store, so that undo is not adopted.
session.on('committed', ({ cause, patch, checkpoint }) => {
  if (cause.origin === SYNC || !current) return;
  if (!patch.some((op) => op.path.startsWith('/model/'))) return;   // a look-only commit
  const undone = cause.kind === 'undo' || cause.kind === 'redo';
  if (undone && edits !== editsAtUndo) return;
  const base = undone && checkpoint !== null ? withStructure(current, checkpoint) : current;
  store.replace((echoed = mergeChanges(base, patch)));
}, { signal });

// The toolbar's undo (a redo button does the same).
export function onUndoClick(): void {
  editsAtUndo = edits;
  session.undo({ actor: 'shopper', origin: 'toolbar-undo' }).catch(reportSyncError);
}

// Store → runtime. Newest wins; a labelled undo step. Never `undo: 'rebase'` here: after a
// shopper edit it would erase the shopper's undo steps.
export function onStoreChange(doc: IConfigurator): void {
  current = doc;
  // The reverse echo (the store repeating our own merge) goes back without `supersede`: equal,
  // it commits nothing and rolls back no open transaction; if a sync queued before the shopper's
  // change replaced it meanwhile, it puts that change back. Never skip it.
  const echo = doc === echoed;
  if (!echo) edits += 1;
  const options = { assetBaseUrl: rootFor(doc), origin: SYNC, supersede: !echo, undo: 'Configure' };
  // Rejects only on invalid input or abort. The checkpoint lets an undo restore the structure.
  const sync = () => session.setSceneModel(doc, { ...options, checkpoint: structureOf(doc) });
  // An internal failure resolves 'rolled-back' with the scene restored (spec section 6.4):
  // report it, and send this document once more unless a newer one has come.
  sync().then(async (r) => {
    if (r.outcome !== 'rolled-back') return;
    reportSyncError(r);
    const again = doc === current ? await sync() : null;
    if (again?.outcome === 'rolled-back') reportSyncError(again);
  }).catch(reportSyncError);
}

ts

import type { DeepReadonly, IModelNode, SceneModel, Session } from '@holostep-configurators/runtime-client/contract';
declare const session: Session;
declare const signal: AbortSignal;
// Read, modify, write: add a shelf and turn a node off, in one recorded step.
// getSceneModel() is DeepReadonly<SceneModel>, which setSceneModel takes as it is: build the
// next model with spreads into a DeepReadonly<SceneModel>. Never annotate it `SceneModel`
// (the read is not assignable to it, TS2322) and never mutate the read.
declare const shelf: IModelNode;                 // a new node with its own nodeId
declare const lampId: string;                    // a root node's nodeId
const model = session.getSceneModel();
if (model) {
  const next: DeepReadonly<SceneModel> = {
    ...model,
    root: [...model.root.map((n) => (n.nodeId === lampId ? { ...n, enabled: false } : n)), shelf],
  };
  await session.setSceneModel(next, { undo: 'Add shelf' });
}

ts

import type { SceneModel, Session } from '@holostep-configurators/runtime-client/contract';
declare const session: Session;
declare const signal: AbortSignal;
// Show one GLB you have, with no saved design (a modeller's check, a quick demo): the smallest
// scene model is one ModelNode with its required fields. Without `enabled: true` it validates
// and is never drawn.
declare const glbUrl: string;                     // absolute, or relative to assetBaseUrl
const model: SceneModel = {
  root: [{
    type: 'ModelNode', nodeId: 'preview', glbUrl, enabled: true,
    position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 }, scale: { x: 1, y: 1, z: 1 },
  }],
};
const r = await session.setSceneModel(model);
for (const p of r.problems) console.warn(p.code, p.url ?? '', p.message); // 'asset-failed'
await session.camera.fit();                       // frame it
console.info(session.describe('preview')?.manifest ?? 'no stamp: manifestFromGlb reads the file');