@volter/sdk 0.0.0-stage → 0.5.204

package/src/kit/transform-mode-request.ts

@@ -0,0 +1,66 @@
+/**
+ * H2, third half — honest gizmo refusal.
+ *
+ * WHY THE TRIGGER IS TOOL ACTIVATION AND NOT DRAG-START. The design record
+ * says "attempting to drag a refused node shows a transient hint". Read
+ * against the code, a literal drag-start trigger is unreachable: a fully
+ * refused selection never gets a gizmo in the first place —
+ * `EditorViewport.syncFromStore` computes `selectedTransformWritable` and
+ * calls `this.detach()` (editor-viewport.ts, the `attach`/`detach` branch), so
+ * `TransformControls` fires no `dragging-changed`: there is nothing attached
+ * to drag. THAT detach is the exact spot where the silence lives.
+ *
+ * The earliest point at which the user has made a real, unambiguous attempt to
+ * transform — as opposed to merely selecting something — is therefore ARMING
+ * the move/rotate/scale tool (W/E/R, the toolbar's mode buttons, the command
+ * palette's Translate/Rotate/Scale Mode actions) while that refused selection
+ * is live. That is the second trigger the brief explicitly allows, and
+ * it is what this module implements. Every UI mode-switch call site routes
+ * through {@link requestTransformMode} instead of `store.setTransformMode`.
+ * (The programmatic `command-listener` path deliberately does not: an
+ * automated `set-transform-mode` command is not a user attempt, and a headless
+ * caller has no viewport to read a hint in.)
+ *
+ * The hint text is the adapter's own `reason`, verbatim — the same sentence
+ * the hierarchy lock tooltip and the inspector field show (doctrine rule 2).
+ * When an adapter refuses without giving a reason we show NOTHING rather than
+ * invent a sentence to paraphrase it with.
+ */
+
+import { resolvePanelAuthoring } from './authoring/panel-authoring';
+import { stageDocument } from './stage-store-registry';
+import { workspaceDocumentSelection } from './workspace-document-registry';
+import type { TransformMode } from '@volter/sdk/kit/shell-store';
+import type { ShellStore } from '@volter/sdk/kit/shell-store';
+import { transformLockSummary } from '@volter/sdk/kit/hierarchy-row-model';
+import { showTransientHint } from '@volter/sdk/kit/transient-hint';
+
+/** Set the transform mode, and NAME the refusal if the live selection is one
+ *  the active adapter will not write. */
+export function requestTransformMode(store: ShellStore, mode: TransformMode): void {
+  store.setTransformMode(mode);
+  // Arming SELECT is not an attempt to transform anything — it is the tool
+  // that transforms nothing (`TransformMode`'s own note) — so the refusal
+  // below, whose whole trigger is "a real, unambiguous attempt to transform",
+  // has nothing to report about it.
+  if (mode === 'select') return;
+  const ids = [...store.selectedEntityIds];
+  if (ids.length === 0) return;
+  // The adapter of the document whose stage asked (a side-by-side document's header asks about
+  // its own), else the one the panels drive: a document stage's selection holds its document's
+  // ids, which the world's composite does not own.
+  const document = stageDocument(store);
+  const adapter =
+    (document === null ? null : workspaceDocumentSelection(document)?.adapter) ?? resolvePanelAuthoring(store).adapter;
+  const editability = adapter.transforms?.editability;
+  if (!editability) return;
+  let reason: string | undefined;
+  for (const id of ids) {
+    const summary = transformLockSummary((channel) => editability(id, channel));
+    // Anything movable in the selection means the gesture is not refused —
+    // the gizmo attaches and moves what it can.
+    if (!summary.locked) return;
+    reason ??= summary.reason;
+  }
+  if (reason) showTransientHint(reason);
+}

package/src/kit/transient-hint.ts

@@ -0,0 +1,78 @@
+/**
+ * The editor's one transient, non-blocking hint channel (H2).
+ *
+ * There was no toast/notification/status-message mechanism in the editor when
+ * this landed (grepped: `toast`, `notification`, `statusMessage`, `hint` —
+ * only unrelated hits), so this is the minimal one. Deliberately: one hint at
+ * a time (a new one replaces the old), auto-dismissing, carrying nothing but
+ * a string it did not write. Blocking dialogs (`window.alert`/`prompt`) are
+ * banned in editor UI.
+ *
+ * Publisher lives here (plain module state, no React) so non-React callers —
+ * hotkeys, the action registry — can raise a hint without importing the
+ * component. `components/TransientHint.tsx` renders it.
+ */
+
+export const TRANSIENT_HINT_MS = 3000;
+
+export interface TransientHint {
+  /** Monotonic — lets the renderer restart its animation on a repeat message. */
+  readonly id: number;
+  readonly message: string;
+}
+
+let current: TransientHint | null = null;
+let timer: ReturnType<typeof setTimeout> | null = null;
+let nextId = 1;
+const listeners = new Set<() => void>();
+
+function emit(): void {
+  for (const listener of listeners) listener();
+}
+
+/** Show `message` for {@link TRANSIENT_HINT_MS}, replacing any live hint. */
+export function showTransientHint(message: string): void {
+  current = { id: nextId++, message };
+  if (timer) clearTimeout(timer);
+  timer = setTimeout(() => {
+    current = null;
+    timer = null;
+    emit();
+  }, TRANSIENT_HINT_MS);
+  emit();
+}
+
+export function dismissTransientHint(): void {
+  if (timer) clearTimeout(timer);
+  timer = null;
+  current = null;
+  emit();
+}
+
+export const subscribeTransientHint = (listener: () => void): (() => void) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+export const transientHint = (): TransientHint | null => current;
+
+/**
+ * A drag that ended with NOTHING accepting it says so.
+ *
+ * `dropEffect === 'none'` at `dragend` is the browser's own word that no drop
+ * target took the payload: the card was released over editor chrome (a tab
+ * strip, the toolbar, a console row) instead of the viewport or a hierarchy
+ * row. That used to be perfectly silent — no hint, no console line, nothing
+ * changed — and a verifier lost a whole round to it before checking
+ * `elementFromPoint` (2026-09-02). A human just sees "the drop did nothing".
+ */
+export function reportUnacceptedAssetDrop(event: { dataTransfer: DataTransfer | null }): void {
+  if (event.dataTransfer?.dropEffect !== 'none') return;
+  // Surface-neutral on purpose: the source cannot know whether the scene is
+  // three or canvas, and a 2D tester told 'the 3D view' would be misled.
+  showTransientHint(
+    'Nothing accepted that drop — release it over the scene view or a hierarchy row.',
+  );
+}

package/src/kit/transport-strip.tsx

@@ -0,0 +1,174 @@
+/**
+ * THE TRANSPORT, DRAWN — the one look every stage gets over its own transport
+ * (WORK.md §The stage transport and the animation door, Step 5).
+ *
+ * It draws nothing until a subject is attached, so a stage with nothing to
+ * show at a time costs an empty render and no chrome. Blender's Timeline is a
+ * SECOND look over the same handle, not a replacement for this one: an origin
+ * decides which subjects attach, never which transport drives them.
+ *
+ * IT HOLDS NO TIME OF ITS OWN. Every value here is read from the snapshot on
+ * each notification — there is no local playhead state to drift, and no clock
+ * in this file. `validate-import-bans.mjs`'s `private-clocks` row scans this
+ * path for `requestAnimationFrame`/`performance.now` for exactly that reason.
+ *
+ * WHILE THE WORLD DRIVES (Play), it goes read-only and SAYS SO. A disabled
+ * button with no reason is the failure this avoids: the refusal the transport
+ * would throw is the sentence shown instead.
+ */
+
+import {
+  EditorIcon,
+  editorIcons,
+  IconButton,
+  Text,
+  TextInput,
+  themeVars,
+} from '@volter/sdk/widgets';
+import { useCallback, useSyncExternalStore } from 'react';
+import type { StageTransportHandle } from '../transport';
+
+/** The speeds the strip offers. Not a free number field: a speed is a viewing
+ *  choice with a few useful values, and a text box invites 0.37. */
+const SPEEDS = [0.25, 0.5, 1, 2] as const;
+
+function formatSeconds(seconds: number, fps: number): string {
+  const frame = Math.round(seconds * fps);
+  return `${seconds.toFixed(2)}s · f${frame}`;
+}
+
+export function TransportStrip({ transport }: { transport: StageTransportHandle | null }) {
+  const snapshot = useSyncExternalStore(
+    useCallback(
+      (listener: () => void) => (transport ? transport.subscribe(listener) : () => {}),
+      [transport],
+    ),
+    useCallback(() => transport?.snapshot() ?? null, [transport]),
+  );
+
+  if (!transport || !snapshot || snapshot.activeSubject === null) return null;
+
+  const driven = snapshot.driver === 'world';
+  const playing = snapshot.playbackState === 'playing';
+  const { start, end, fps, loop } = snapshot.range;
+  const active = snapshot.subjects.find((s) => s.id === snapshot.activeSubject);
+  // Two different pickers, and they are not the same question: SUBJECTS are
+  // the several things this stage can show at a time, CLIPS are the several
+  // animations one subject has. A Blender action is a subject with no clips.
+  const subjects = snapshot.subjects.length > 1 ? snapshot.subjects : null;
+  const clips = transport.activeClips();
+
+  return (
+    <section
+      aria-label="Transport"
+      data-testid="stage-transport-strip"
+      style={{
+        display: 'flex',
+        alignItems: 'center',
+        gap: 'var(--volter-space-2)',
+        padding: 'var(--volter-space-1) var(--volter-space-3)',
+        borderTop: `var(--volter-stroke-resting) solid ${themeVars.boundary.default}`,
+        background: themeVars.surface.raised,
+      }}
+    >
+      <IconButton
+        size="compact"
+        aria-label={playing ? 'Pause' : 'Play'}
+        disabled={driven}
+        onClick={() => (playing ? transport.pause() : transport.play())}
+      >
+        <EditorIcon icon={playing ? editorIcons.transport.pause : editorIcons.transport.play} />
+      </IconButton>
+      <IconButton
+        size="compact"
+        aria-label="Stop"
+        disabled={driven}
+        onClick={() => transport.stop()}
+      >
+        <EditorIcon icon={editorIcons.transport.stop} />
+      </IconButton>
+
+      <TextInput
+        aria-label="Playhead"
+        type="range"
+        min={start}
+        max={end}
+        step={1 / fps}
+        value={snapshot.time}
+        disabled={driven}
+        onChange={(event) => transport.seek(Number(event.target.value))}
+        style={{ flex: 1 }}
+      />
+
+      <Text as="span" variant="caption">
+        {formatSeconds(snapshot.time, fps)}
+      </Text>
+
+      {subjects ? (
+        <select
+          aria-label="Subject"
+          value={snapshot.activeSubject}
+          disabled={driven}
+          onChange={(event) => transport.setActiveSubject(event.target.value)}
+        >
+          {subjects.map((subject) => (
+            <option key={subject.id} value={subject.id}>
+              {subject.label}
+            </option>
+          ))}
+        </select>
+      ) : null}
+
+      {clips ? (
+        <select
+          aria-label="Clip"
+          disabled={driven}
+          onChange={(event) => transport.setActiveClip(event.target.value)}
+        >
+          {clips.map((clip) => (
+            <option key={clip.id} value={clip.id}>
+              {clip.label}
+            </option>
+          ))}
+        </select>
+      ) : null}
+
+      <label style={{ display: 'flex', alignItems: 'center', gap: 'var(--volter-space-1)' }}>
+        <input
+          type="checkbox"
+          checked={loop}
+          disabled={driven}
+          onChange={(event) => transport.setLoop(event.target.checked)}
+        />
+        <Text as="span" variant="caption">
+          Loop
+        </Text>
+      </label>
+
+      <select
+        aria-label="Speed"
+        value={String(snapshot.timeScale)}
+        disabled={driven}
+        onChange={(event) => transport.setTimeScale(Number(event.target.value))}
+      >
+        {SPEEDS.map((speed) => (
+          <option key={speed} value={String(speed)}>
+            {speed}×
+          </option>
+        ))}
+      </select>
+
+      {driven ? (
+        // The refusal the write verbs would throw, shown instead of a disabled
+        // control with no reason.
+        <Text as="span" variant="caption">
+          The world is driving time (Play); pause the game to scrub
+        </Text>
+      ) : active ? (
+        <Text as="span" variant="caption">
+          {active.label}
+        </Text>
+      ) : null}
+    </section>
+  );
+}

package/src/kit/ui-source/adapter-region-includes.ts

@@ -0,0 +1,238 @@
+import ts from 'typescript';
+
+/**
+ * A SYNCHRONOUS, source-only read of what a project's `editor/volter.adapter.ts`
+ * declares about which files belong to which SURFACE: each region's `include`
+ * globs, and the additional surfaces it `mounts` — stated either as parameters
+ * layered onto the `'manifest-roots'` rule (`regionIncludes`, what every
+ * first-party project uses) or inside an explicit `regions` list (the
+ * full-replacement form). Pure — the dev server adds
+ * the filesystem and a cache (`server/adapter-region-includes.ts`); the
+ * browser-hosted Content index reads the same file through its storage backend.
+ *
+ * WHY A STATIC READ AND NOT AN IMPORT. The adapter module's contract
+ * (`@volter/project/adapter/adapter-module`, ARCHITECTURE-CORE §The editor protocol) is
+ * that its TOP LEVEL is "a STATICALLY EVALUABLE BINDING TABLE, readable without
+ * booting the game" — plain data, closures only inside `observation[].answer`.
+ * This module takes the contract at its word for the one consumer that cannot
+ * take any other route: the OID stamping transform runs in a Vite `transform`
+ * hook, synchronously, per project `.tsx`, long before any browser-tier adapter
+ * load has happened (and in `vite build`, where none ever will). The same
+ * placement test ARCHITECTURE-CORE applies to manifest-vs-adapter fields —
+ * "readable WITHOUT EVALUATING ANY MODULE … e.g. Vite config time" — is what
+ * makes a static read of a statically-evaluable table the right instrument here
+ * rather than a second declaration home.
+ *
+ * It reads those properties and reads them literally. Anything it cannot read
+ * literally is reported as {@link AdapterRegionIncludes.unreadable} — never
+ * silently treated as "no includes", because a silently dropped declaration is
+ * indistinguishable from a declaration that worked, which is the whole failure
+ * class this rung exists to end. `packages/sdk/src/kit/project-adapter.ts` (the
+ * real loader, which IMPORTS the module) stays the validation authority: this
+ * read never accepts anything that loader would reject, it only declines to
+ * answer.
+ */
+
+/** One ADDITIONAL mounted surface a region declares — see
+ *  `@volter/project/adapter/adapter-module`'s `AdapterRegion.mounts`. */
+export interface AdapterRegionMountDeclaration {
+  readonly surface: 'three' | 'canvas' | 'dom';
+  readonly include: readonly string[];
+}
+
+/** Region id -> the `include` globs it declares, and the additional surfaces it
+ *  mounts. */
+export interface AdapterRegionIncludes {
+  readonly byRegionId: ReadonlyMap<string, readonly string[]>;
+  /** Region id -> the surfaces it mounts BESIDE its manifest root's own
+   *  adapter, each with the files that render on it. Read here for the same
+   *  reason `include` is: it is the one place a root's second surface can be
+   *  stated, and every OID/HMR/Content reader answers from the same table. */
+  readonly mountsByRegionId: ReadonlyMap<string, readonly AdapterRegionMountDeclaration[]>;
+  /**
+   * `true` when the file HAS a `regions` binding this static read could not
+   * evaluate (a spread, an imported constant, a computed value). The caller
+   * reports it; it never reads as "declares nothing".
+   */
+  readonly unreadable: boolean;
+}
+
+export const EMPTY_REGION_INCLUDES: AdapterRegionIncludes = {
+  byRegionId: new Map(),
+  mountsByRegionId: new Map(),
+  unreadable: false,
+};
+
+const UNREADABLE_REGION_INCLUDES: AdapterRegionIncludes = {
+  byRegionId: new Map(),
+  mountsByRegionId: new Map(),
+  unreadable: true,
+};
+
+function stringLiteralOf(node: ts.Node | undefined): string | undefined {
+  return node && ts.isStringLiteralLike(node) ? node.text : undefined;
+}
+
+function stringArrayOf(node: ts.Node | undefined): string[] | undefined {
+  if (!node || !ts.isArrayLiteralExpression(node)) return undefined;
+  const out: string[] = [];
+  for (const element of node.elements) {
+    const value = stringLiteralOf(element);
+    if (value === undefined) return undefined;
+    out.push(value);
+  }
+  return out;
+}
+
+function propertyOf(object: ts.ObjectLiteralExpression, name: string): ts.Expression | undefined {
+  for (const member of object.properties) {
+    if (!ts.isPropertyAssignment(member)) continue;
+    const key = ts.isIdentifier(member.name)
+      ? member.name.text
+      : (stringLiteralOf(member.name) ?? null);
+    if (key === name) return member.initializer;
+  }
+  return undefined;
+}
+
+/**
+ * What the module's default export gives this reader.
+ *
+ * The three outcomes are deliberately distinct, because two of them used to
+ * collapse into one and that collapse WAS a silent hole: `export default def`
+ * (a hoisted `const def = defineAdapter({…})`) and `defineAdapter(config)`
+ * both evaluate fine in `project-adapter.ts` — which validates the exported
+ * VALUE — while this reader saw "not a readable literal" and answered "no
+ * includes, nothing to report". The loader would honor an `include` this tier
+ * had silently dropped, which is exactly the disagreement the module docblock
+ * promises cannot happen. Both are now `'unreadable'`.
+ */
+type DefinitionRead =
+  /** A statically readable argument object (possibly with no `regions`). */
+  | { readonly kind: 'literal'; readonly literal: ts.ObjectLiteralExpression }
+  /** A zero-argument call — `nativeAdapter()`. The legitimate empty. */
+  | { readonly kind: 'empty' }
+  /** No default export at all: nothing here worth flagging; the loader is the
+   *  validation authority and an absent adapter is the native default. */
+  | { readonly kind: 'absent' }
+  /** A default export this reader cannot evaluate but the loader can. */
+  | { readonly kind: 'unreadable' };
+
+function readDefinition(source: ts.SourceFile): DefinitionRead {
+  for (const statement of source.statements) {
+    if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+    const call = statement.expression;
+    if (!ts.isCallExpression(call)) return { kind: 'unreadable' };
+    const arg = call.arguments[0];
+    if (arg === undefined) return { kind: 'empty' };
+    return ts.isObjectLiteralExpression(arg)
+      ? { kind: 'literal', literal: arg }
+      : { kind: 'unreadable' };
+  }
+  return { kind: 'absent' };
+}
+
+/** Read `regions[].include` out of one adapter source. Pure — the fs half is
+ *  `server/adapter-region-includes.ts`, so this is directly testable, and
+ *  `adapter-region-includes-conformance.test.ts` pins it against what
+ *  `parseAdapterDefinition` yields from EVALUATING the same source. */
+export function parseAdapterRegionIncludes(code: string): AdapterRegionIncludes {
+  const source = ts.createSourceFile('editor/volter.adapter.ts', code, ts.ScriptTarget.Latest, true);
+  const definition = readDefinition(source);
+  if (definition.kind === 'unreadable') return UNREADABLE_REGION_INCLUDES;
+  if (definition.kind !== 'literal') return EMPTY_REGION_INCLUDES;
+  const regions = propertyOf(definition.literal, 'regions');
+  const overlay = propertyOf(definition.literal, 'regionIncludes');
+  const listed = regions !== undefined && !ts.isStringLiteralLike(regions);
+  // The two forms may not be combined — `defineAdapter` rejects that pairing by
+  // name, so the module never loads. This tier declines to answer rather than
+  // reporting half of an invalid table.
+  if (listed && overlay !== undefined) return UNREADABLE_REGION_INCLUDES;
+  // Absent, or the `'manifest-roots'` RULE: the derivation runs, and the
+  // declared PARAMETERS beside it are what a native project states (decision,
+  // 2026-08-17). Neither present is a real answer — pure reach — not a gap.
+  if (!listed) return overlay ? layeredIncludes(overlay) : EMPTY_REGION_INCLUDES;
+  if (!ts.isArrayLiteralExpression(regions)) return UNREADABLE_REGION_INCLUDES;
+
+  const byRegionId = new Map<string, readonly string[]>();
+  const mountsByRegionId = new Map<string, readonly AdapterRegionMountDeclaration[]>();
+  for (const element of regions.elements) {
+    if (!ts.isObjectLiteralExpression(element)) return UNREADABLE_REGION_INCLUDES;
+    const id = stringLiteralOf(propertyOf(element, 'id'));
+    if (id === undefined) return UNREADABLE_REGION_INCLUDES;
+    const include = propertyOf(element, 'include');
+    if (include !== undefined) {
+      const globs = stringArrayOf(include);
+      if (globs === undefined) return UNREADABLE_REGION_INCLUDES;
+      byRegionId.set(id, globs);
+    }
+    const mounts = propertyOf(element, 'mounts');
+    if (mounts === undefined) continue;
+    const declared = mountArrayOf(mounts);
+    if (declared === undefined) return UNREADABLE_REGION_INCLUDES;
+    mountsByRegionId.set(id, declared);
+  }
+  return { byRegionId, mountsByRegionId, unreadable: false };
+}
+
+/**
+ * Read the LAYERED form: `regionIncludes`, the per-region parameters the
+ * `'manifest-roots'` rule takes (`@volter/project/adapter/adapter-module`'s
+ * {@link AdapterDefinition.regionIncludes}, decision 2026-08-17).
+ *
+ * Statically readable BY CONSTRUCTION — it is an object literal of object
+ * literals of string arrays, sitting beside the `regions` string in the same
+ * argument object — which is exactly why the decision put the parameters here
+ * rather than behind a builder call. Anything that is NOT that literal shape
+ * (a spread, an imported table, a computed key) is `unreadable`, on the same
+ * terms as every other shape this reader declines: the loader would honor it,
+ * so silence about it would be the drift this module exists to prevent.
+ */
+function layeredIncludes(node: ts.Expression): AdapterRegionIncludes {
+  if (!ts.isObjectLiteralExpression(node)) return UNREADABLE_REGION_INCLUDES;
+  const byRegionId = new Map<string, readonly string[]>();
+  const mountsByRegionId = new Map<string, readonly AdapterRegionMountDeclaration[]>();
+  for (const member of node.properties) {
+    if (!ts.isPropertyAssignment(member)) return UNREADABLE_REGION_INCLUDES;
+    const id = ts.isIdentifier(member.name) ? member.name.text : stringLiteralOf(member.name);
+    const overlay = overlayOf(member.initializer);
+    if (id === undefined || overlay === undefined) return UNREADABLE_REGION_INCLUDES;
+    if (overlay.include) byRegionId.set(id, overlay.include);
+    if (overlay.mounts) mountsByRegionId.set(id, overlay.mounts);
+  }
+  return { byRegionId, mountsByRegionId, unreadable: false };
+}
+
+/** One `regionIncludes` entry, read literally. `undefined` for anything this
+ *  reader cannot evaluate — never a partial answer. */
+function overlayOf(
+  node: ts.Expression,
+): { include?: string[]; mounts?: AdapterRegionMountDeclaration[] } | undefined {
+  if (!ts.isObjectLiteralExpression(node)) return undefined;
+  const includeNode = propertyOf(node, 'include');
+  const include = includeNode === undefined ? undefined : stringArrayOf(includeNode);
+  if (includeNode !== undefined && include === undefined) return undefined;
+  const mountsNode = propertyOf(node, 'mounts');
+  const mounts = mountsNode === undefined ? undefined : mountArrayOf(mountsNode);
+  if (mountsNode !== undefined && mounts === undefined) return undefined;
+  return { ...(include ? { include } : {}), ...(mounts ? { mounts } : {}) };
+}
+
+/** Read a region's `mounts` array literally. `undefined` — not an empty list —
+ *  for anything this reader cannot evaluate, so the caller reports it rather
+ *  than silently dropping a surface the real loader will honor. */
+function mountArrayOf(node: ts.Expression): AdapterRegionMountDeclaration[] | undefined {
+  if (!ts.isArrayLiteralExpression(node)) return undefined;
+  const out: AdapterRegionMountDeclaration[] = [];
+  for (const element of node.elements) {
+    if (!ts.isObjectLiteralExpression(element)) return undefined;
+    const surface = stringLiteralOf(propertyOf(element, 'surface'));
+    if (surface !== 'three' && surface !== 'canvas' && surface !== 'dom') return undefined;
+    const include = propertyOf(element, 'include');
+    if (include === undefined) return undefined;
+    const globs = stringArrayOf(include);
+    if (globs === undefined || globs.length === 0) return undefined;
+    out.push({ surface, include: globs });
+  }
+  return out;
+}