@volter/editor-game 0.5.65

package/NOTICE

@@ -0,0 +1,23 @@
+Copyright 2026 Volter AI, Inc.
+
+The files in this package were imported from volter-ai/vgai-engine at commit
+09c2749ce. LICENSE contains the AGPL-3.0-only license they retain.
+
+  packages/game/src, packages/game/contributions (@vgai/game)
+    -> src, contributions
+  packages/dom/src, packages/dom/contributions (@vgai/dom)
+    -> src/react, contributions/react
+  packages/threejs/src except viewport/ and capture/, packages/threejs/contributions
+  (@vgai/threejs) -> src/three, contributions/three
+  host modules of packages/editor/src (@vgai/editor) -> src/host, including
+  gameplay-export.ts and document-preview-three.ts, and the world-root stage
+  (components/world-root-stage.ts and the modules it draws with)
+  src/host/components/world-root-stage-binding.tsx is transcribed from the
+  world-root parts of packages/editor/src/components/stage-overlay-set.tsx;
+  src/host/components/scene-document.tsx and
+  contributions/scene-document.service.ts from the Scene document half of
+  packages/editor/src/components/CenterDocuments.tsx
+
+src/host/sdk/tools.ts was imported from packages/vgai-sdk/src/tools.ts, part of
+the Apache-2.0 @vgai/sdk package, and retains that license. It re-exports the
+Apache-2.0 tool contract of @volter/editor-sdk.

package/contributions/asset-budget-asset.menu.ts

@@ -0,0 +1,26 @@
+/**
+ * `Open in Asset Budget` on ONE asset — the Asset Browser's `asset` context
+ * menu (`@volter/editor-sdk/chrome`), whose items are invoked with the asset's
+ * project path. It was a built-in item in `AssetBrowser.tsx`; the budget is
+ * this package's document, so the item is this package's too, and a models
+ * project's context menu simply does not carry it.
+ */
+import type { MenuContribution } from '@volter/editor-sdk/chrome';
+import { openAssetBudgetDocument } from '../src/asset-budget/AssetBudgetPanel';
+
+export const point = 'workspace.menu';
+
+export const menu: MenuContribution = {
+  menu: 'asset',
+  items: [
+    {
+      id: 'open-budget',
+      label: 'Open in Asset Budget',
+      testId: 'asset-context-open-budget',
+      execute: ({ assetPath }) => {
+        if (assetPath === undefined) return;
+        openAssetBudgetDocument(assetPath);
+      },
+    },
+  ],
+};

package/contributions/asset-budget.action.ts

@@ -0,0 +1,18 @@
+/**
+ * `Open Asset Budget` in the command palette — the same document Window ▸
+ * Asset Budget opens, through the action point.
+ */
+import type { ActionContribution } from '@volter/editor-sdk/chrome';
+import { openAssetBudgetDocument } from '../src/asset-budget/AssetBudgetPanel';
+
+export const point = 'workspace.action';
+
+export const actions: ActionContribution['actions'] = [
+  {
+    id: 'asset-budget',
+    label: 'Open Asset Budget',
+    execute: () => {
+      openAssetBudgetDocument();
+    },
+  },
+];

package/contributions/asset-budget.document.tsx

@@ -0,0 +1,21 @@
+/**
+ * THE ASSET BUDGET (`workspace.document`) — what a project's shipped assets
+ * cost: per-asset size, VRAM estimate, triangle count, who references it, and
+ * the glTF/KTX2 optimizers that rewrite it. A singleton center document,
+ * opened from Window ▸ Asset Budget, the palette, or an asset's own context
+ * menu (`asset-budget-asset.menu.ts`, which hands it the asset's path).
+ *
+ * It ships with `@volter/editor-game` because a budget is a GAME's question — what the
+ * player downloads and what the GPU holds. A folder of models has no shipped
+ * asset set and no Asset Budget tab.
+ */
+
+import type { ToolContributionProps } from '@volter/editor-sdk/contributions';
+import { AssetBudgetPanel } from '../src/asset-budget/AssetBudgetPanel';
+
+export const point = 'workspace.document';
+export const title = 'Asset Budget';
+
+export default function AssetBudgetDocument(_props: ToolContributionProps) {
+  return <AssetBudgetPanel />;
+}

package/contributions/asset-budget.menu.ts

@@ -0,0 +1,22 @@
+/**
+ * Window ▸ Asset Budget — the document in the application menu, beside the
+ * editor's own windows.
+ */
+import type { MenuContribution } from '@volter/editor-sdk/chrome';
+import { openAssetBudgetDocument } from '../src/asset-budget/AssetBudgetPanel';
+
+export const point = 'workspace.menu';
+
+export const menu: MenuContribution = {
+  menu: 'window',
+  items: [
+    {
+      id: 'asset-budget',
+      label: 'Asset Budget',
+      testId: 'menu-asset-budget',
+      execute: () => {
+        openAssetBudgetDocument();
+      },
+    },
+  ],
+};

package/contributions/audio-unlock.service.ts

@@ -0,0 +1,17 @@
+/**
+ * The page-level audio services of a RUNNING game (`@volter/editor-sdk/services`,
+ * a `workspace.service` contribution): the host-level AudioContext unlock —
+ * a game's own unlock listeners go through the realm's gated re-dispatch,
+ * which is not the trusted gesture stack browsers require — and the Web
+ * Audio pose guard's editor diagnostic. Both are page-wide and idempotent;
+ * neither matters to a project that plays nothing.
+ */
+import { installAudioPoseGuard } from '../src/services/audio-pose-guard';
+import { installGameAudioUnlock } from '../src/services/game-audio-unlock';
+
+export const point = 'workspace.service';
+
+export function start(): void {
+  installGameAudioUnlock();
+  installAudioPoseGuard();
+}

package/contributions/audio.utility.tsx

@@ -0,0 +1,15 @@
+/**
+ * The Audio debugger as a drawer tab (W3c): node graph, transport strip,
+ * per-bus meters and the event log over the inspected session's
+ * `AudioAdapter`. Always on offer: the editor project registers the same
+ * first-party graph in edit mode, and Play supplies the running game's.
+ */
+import { AudioDebuggerPanel } from '../src/audio/AudioDebuggerPanel';
+
+export const point = 'workspace.utility';
+export const title = 'Audio';
+export const order = 26;
+
+export default function AudioUtility() {
+  return <AudioDebuggerPanel />;
+}

package/contributions/autoplay.service.ts

@@ -0,0 +1,48 @@
+/**
+ * THE PLAY ENTRY THAT IS NOT A CLICK (`@volter/editor-sdk/services`, a
+ * `workspace.service` contribution): `?play=1`, the URL asking this session to
+ * open playing.
+ *
+ * It was an effect in `components/DefaultEditorLayout.tsx`; the shell's layout
+ * must not name Play to honour a query param. The boot gate that makes the
+ * timing safe is armed before any descendant effect (see
+ * `initial-project.ts`'s header), and a service starts after the contribution
+ * pass — which can be before a project session's store exists — so the entry
+ * waits for the store's ARRIVAL (`@editor/shell-store-door`, `onShellStore`,
+ * which fires at once when one is already registered) rather than for a React
+ * mount.
+ *
+ * It reports its failure to the editor console — `vgai console` is what reads
+ * it — rather than leaving a stopped surface with no reason on it.
+ */
+import { onShellStore } from '@volter/editor-core/shell-store-door';
+import { editorHost } from '@volter/editor-sdk/host';
+import { enterPlayMode } from '../src/play/play-mode';
+
+export const point = 'workspace.service';
+
+function enter(reason: string): void {
+  void enterPlayMode().catch((error) => {
+    editorHost().console.error(
+      `${reason}: ${error instanceof Error ? error.message : String(error)}`,
+      'play',
+    );
+  });
+}
+
+export function start(): () => void {
+  let timer: number | undefined;
+  let urlPlayStarted = false;
+  const stopStore = onShellStore(() => {
+    if (urlPlayStarted) return;
+    if (new URLSearchParams(window.location.search).get('play') !== '1') return;
+    urlPlayStarted = true;
+    // Next task, not this one: the store has only just been registered, and
+    // the boot gate the entry rides is armed on the same turn.
+    timer = window.setTimeout(() => enter('Could not enter requested Play mode'), 0);
+  });
+  return () => {
+    if (timer !== undefined) window.clearTimeout(timer);
+    stopStore();
+  };
+}

package/contributions/bridge.command.ts

@@ -0,0 +1,172 @@
+/**
+ * The PAGE-BRIDGE verbs of the session wire (`@volter/editor-sdk/commands`, a
+ * `workspace.command` contribution): the session-generic `bridge-call`, the
+ * game-stack still, and the gameplay recorder's start/stop/timeline.
+ *
+ * These hand control to the GAME's own code (or read its pixels), so their
+ * budgets are the game's, not the editor's — carried here from the host's own
+ * table row for row.
+ *
+ * `bridge-recording-export` deliberately did NOT come with them: it reads and
+ * subscribes to the EditorShellStore's `playState` (pause is its
+ * precondition, and a play-state change is what cancels it), and a
+ * contributed handler is handed the command only. It stays in
+ * `command-listener.ts` with the host gate that refuses every command while
+ * an export owns the paused run, until Play itself leaves the host.
+ *
+ * Play mode, the recorders and the composite capture are the game skew's own
+ * modules, still housed in the editor until Play leaves the host (WORK.md
+ * §The workbench, G); they are reached through the `@editor/*` alias the
+ * editor's Vite serves to every contribution, and become this package's own
+ * imports when they move. Nothing here is host API.
+ */
+
+import { getActiveSystems } from '@volter/editor-core/authoring/active-systems';
+import {
+  activeGameplayRecordingTimeline,
+  startGameplayRecording,
+  stopGameplayRecording,
+} from '../src/host/gameplay-recording';
+import { captureGameplayReplay, exportGameplayReplay } from '@volter/editor-core/gameplay-replay';
+import type { CommandContribution } from '@volter/editor-sdk/commands';
+import { handleBridgeCall } from '../src/bridge/call';
+import { hasLiveDebugPlane } from '../src/bridge/dispatch';
+import { captureLiveCanvasFrame, refreshRecordingFrame } from '../src/bridge/live-frames';
+import { handleBridgeScreenshot } from '../src/bridge/screenshot';
+import { notPlayingResult, structuredErrorResult } from '../src/command-results';
+import { isIngestActive } from '../src/ingest/active-ingest';
+import { getInstanceContainer, isPlayModeActive } from '../src/play/play-mode';
+
+export const point = 'workspace.command';
+
+export const commands: CommandContribution['commands'] = {
+  // #140 — the session-generic debug-seam relay: see `dispatchBridgeMethod`'s
+  // doc comment for why this is a distinct primitive from the NAMED
+  // debug-seam verbs (`list-gameplay-state` etc., `gameplay.command.ts`)
+  // rather than a duplicate of them.
+  'bridge-call': { timeoutMs: 60_000, derivedRefresh: 'always', handle: handleBridgeCall },
+  'bridge-screenshot': {
+    timeoutMs: 15_000,
+    derivedRefresh: 'if-content-changed',
+    handle: handleBridgeScreenshot,
+  },
+  'bridge-recording-start': {
+    timeoutMs: 15_000,
+    derivedRefresh: 'none',
+    handle: async (cmd) => {
+      if (!isPlayModeActive() && !hasLiveDebugPlane() && !isIngestActive()) {
+        return notPlayingResult();
+      }
+      const container = getInstanceContainer();
+      if (!container) {
+        return { ok: false, error: 'no play-mode game surface is mounted yet' };
+      }
+      // Recording belongs to the RUNNING game, never the edit-time Asset Lab
+      // audio fallback. A game with no audio adapter must produce an honest
+      // video-only WebM instead of attaching a suspended preview track.
+      const audio = getActiveSystems().audio?.acquireRecordingStream?.() ?? null;
+      try {
+        const started = await startGameplayRecording(container, {
+          fps: typeof cmd['fps'] === 'number' ? cmd['fps'] : undefined,
+          format:
+            cmd['format'] === 'canvas-dom' || cmd['format'] === 'composite-webm'
+              ? cmd['format']
+              : undefined,
+          name: typeof cmd['name'] === 'string' || cmd['name'] === null ? cmd['name'] : undefined,
+          canvasFrame: captureLiveCanvasFrame,
+          refreshFrame: refreshRecordingFrame,
+          audio,
+        });
+        return { ok: true, data: { ...started } };
+      } catch (error) {
+        return structuredErrorResult(error);
+      }
+    },
+  },
+  'bridge-recording-stop': {
+    timeoutMs: 60_000,
+    derivedRefresh: 'none',
+    handle: async () => {
+      try {
+        const capture = await stopGameplayRecording();
+        return { ok: true, data: { ...capture } };
+      } catch (error) {
+        return structuredErrorResult(error);
+      }
+    },
+  },
+  'bridge-recording-timeline': {
+    derivedRefresh: 'none',
+    handle: () => {
+      const timeline = activeGameplayRecordingTimeline();
+      return timeline === null
+        ? { ok: false, error: 'no gameplay recording is active' }
+        : { ok: true, data: { ...timeline } };
+    },
+  },
+  'bridge-recording-replay-capture': {
+    timeoutMs: 60_000,
+    derivedRefresh: 'none',
+    handle: async (cmd) => {
+      try {
+        if (typeof cmd['replayPath'] !== 'string') {
+          return { ok: false, error: 'replayPath is required' };
+        }
+        if (typeof cmd['positionMs'] !== 'number' || !Number.isFinite(cmd['positionMs'])) {
+          return { ok: false, error: 'finite positionMs is required' };
+        }
+        const capture = await captureGameplayReplay(cmd['replayPath'], cmd['positionMs']);
+        return { ok: true, data: { ...capture } };
+      } catch (error) {
+        return structuredErrorResult(error);
+      }
+    },
+  },
+  'bridge-recording-replay-export': {
+    timeoutMs: 600_000,
+    derivedRefresh: 'none',
+    handle: async (cmd) => {
+      try {
+        if (typeof cmd['replayPath'] !== 'string')
+          return { ok: false, error: 'replayPath is required' };
+        const { blob, ...result } = await exportGameplayReplay({
+          replayPath: cmd['replayPath'],
+          ...(typeof cmd['fps'] === 'number' ? { fps: cmd['fps'] } : {}),
+          ...(typeof cmd['startMs'] === 'number' ? { startMs: cmd['startMs'] } : {}),
+          ...(typeof cmd['endMs'] === 'number' ? { endMs: cmd['endMs'] } : {}),
+        });
+        const {
+          beginGameplayRecordingSink,
+          appendGameplayRecordingChunk,
+          finishGameplayRecordingSink,
+          abortGameplayRecordingSink,
+        } = await import('@volter/editor-core/editor-api');
+        const sink = await beginGameplayRecordingSink({
+          startedAt: new Date().toISOString(),
+          mimeType: 'video/webm',
+          purpose: 'export',
+          name: typeof cmd['name'] === 'string' ? cmd['name'] : `replay-export-${Date.now()}`,
+        });
+        try {
+          for (
+            let offset = 0, sequence = 0;
+            offset < blob.size;
+            offset += 4 * 1024 * 1024, sequence++
+          )
+            await appendGameplayRecordingChunk(
+              sink,
+              sequence,
+              blob.slice(offset, offset + 4 * 1024 * 1024),
+            );
+          await finishGameplayRecordingSink(sink, 'post-processed canvas and DOM recording');
+        } catch (error) {
+          await abortGameplayRecordingSink(sink);
+          throw error;
+        }
+        return { ok: true, data: { ...result, path: sink.path } };
+      } catch (error) {
+        return structuredErrorResult(error);
+      }
+    },
+  },
+};

package/contributions/build-profiles.document.tsx

@@ -0,0 +1,21 @@
+/**
+ * BUILD PROFILES (`workspace.document`) — the project's build configuration
+ * as a center document: the build-role targets, the manifest fields a build
+ * reads, and the Build trigger. A document rather than a dialog because the
+ * configuration is a persistent authored surface (it writes
+ * `vgai.project.json` through the history service) someone tunes and re-runs,
+ * and because a modal would block the viewport while a build streams.
+ *
+ * It ships with `@volter/editor-game`, so a folder of models has no Build Profiles tab
+ * and no Build button at all.
+ */
+
+import type { ToolContributionProps } from '@volter/editor-sdk/contributions';
+import { BuildProfilesPanel } from '../src/build/BuildProfilesPanel';
+
+export const point = 'workspace.document';
+export const title = 'Build Profiles';
+
+export default function BuildProfilesDocument(_props: ToolContributionProps) {
+  return <BuildProfilesPanel />;
+}

package/contributions/build-progress.status.tsx

@@ -0,0 +1,45 @@
+/**
+ * BUILD PROGRESS (`workspace.status`) — the compact status-bar item for the
+ * running build: `Building <target>…`, then complete or failed. Nothing at
+ * all while idle, so the strip carries no row for a build nobody started.
+ */
+
+import { useSyncExternalStore } from 'react';
+import {
+  buildSessionVersion,
+  getBuildSession,
+  subscribeBuildSession,
+} from '../src/build/build-session';
+
+export const point = 'workspace.status';
+export const title = 'Build Progress';
+export const align = 'left';
+export const order = 30;
+
+export default function BuildProgressStatus() {
+  useSyncExternalStore(subscribeBuildSession, buildSessionVersion, buildSessionVersion);
+  const session = getBuildSession();
+  if (session.phase === 'idle') return null;
+  if (session.phase === 'building') {
+    return (
+      <span
+        className="vgai-status-copy"
+        data-testid="status-build-progress"
+        data-build-phase="building"
+        data-status-tone="accent"
+      >
+        Building {session.target}…
+      </span>
+    );
+  }
+  return (
+    <span
+      className="vgai-status-copy"
+      data-testid="status-build-progress"
+      data-build-phase={session.result?.ok ? 'complete' : 'failed'}
+      data-status-tone={session.result?.ok ? 'success' : 'danger'}
+    >
+      {session.result?.ok ? 'Build complete' : 'Build failed'}
+    </span>
+  );
+}

package/contributions/build.action.ts

@@ -0,0 +1,26 @@
+/**
+ * The palette's BUILD actions — `Build for Web (itch.io)` and
+ * `Build for Desktop (Steam)`, both opening the Build Profiles document where
+ * the target is chosen and the build is run.
+ */
+import type { ActionContribution } from '@volter/editor-sdk/chrome';
+import { openBuildProfilesDocument } from '../src/build/build-session';
+
+export const point = 'workspace.action';
+
+export const actions: ActionContribution['actions'] = [
+  {
+    id: 'build.web',
+    label: 'Build for Web (itch.io)',
+    execute: () => {
+      openBuildProfilesDocument();
+    },
+  },
+  {
+    id: 'build.steam',
+    label: 'Build for Desktop (Steam)',
+    execute: () => {
+      openBuildProfilesDocument();
+    },
+  },
+];

package/contributions/build.command.ts

@@ -0,0 +1,27 @@
+/**
+ * `show-build` (`@volter/editor-sdk/commands`) — the session verb that opens the
+ * Build Profiles document. It sat in `command-listener.ts` because opening a
+ * workspace document needed the live shell store; the host door's
+ * `workspace.openContributedDocument` is that reach, so the verb travels with
+ * the document it opens. Its relay budget is the host table's row it replaces
+ * (`alwaysRefresh()`: opening the document changes what a caller reads next).
+ */
+import type { CommandContribution } from '@volter/editor-sdk/commands';
+import { openBuildProfilesDocument } from '../src/build/build-session';
+
+export const point = 'workspace.command';
+
+export const commands: CommandContribution['commands'] = {
+  'show-build': {
+    derivedRefresh: 'always',
+    handle: () => {
+      if (!openBuildProfilesDocument()) {
+        return {
+          ok: false,
+          error: 'The Build Profiles document is not registered in this session.',
+        };
+      }
+      return { ok: true };
+    },
+  },
+};

package/contributions/build.header.tsx

@@ -0,0 +1,37 @@
+/**
+ * THE EXPORT BUTTON (`workspace.header`) — the door into Build
+ * Profiles, in the project header's contributed cluster beside the Play
+ * transport. Disabled while Play runs: a build reads the project from disk,
+ * and a running game holds ephemeral edits that are not on disk.
+ */
+
+import { editorHost } from '@volter/editor-sdk/host';
+import { Button, EditorIcon, editorIcons } from '@volter/editor-sdk/widgets';
+import { useSyncExternalStore } from 'react';
+import { openBuildProfilesDocument } from '../src/build/build-session';
+
+export const point = 'workspace.header';
+export const order = 10;
+
+export default function BuildHeader() {
+  const { session } = editorHost();
+  const playState = useSyncExternalStore(session.subscribe, session.playState, session.playState);
+  const playing = playState !== 'stopped';
+  return (
+    <Button
+      variant="ghost"
+      size="compact"
+      data-testid="project-export"
+      aria-label="Export project"
+      disabled={playing}
+      title={playing ? 'Stop Play mode before exporting the project' : 'Export project'}
+      className="vgai-chrome-island vgai-glass-island"
+      onClick={() => {
+        openBuildProfilesDocument();
+      }}
+    >
+      <EditorIcon icon={editorIcons.action.export} />
+      Export
+    </Button>
+  );
+}

package/contributions/build.menu.ts

@@ -0,0 +1,31 @@
+/**
+ * Window ▸ Build Profiles / Build Output — the two build surfaces in the
+ * application menu. A build spawns `npm run <script>` on the session's own
+ * server.
+ */
+import type { MenuContribution } from '@volter/editor-sdk/chrome';
+import { openBuildProfilesDocument, showBuildOutput } from '../src/build/build-session';
+
+export const point = 'workspace.menu';
+
+export const menu: MenuContribution = {
+  menu: 'window',
+  items: [
+    {
+      id: 'build-profiles',
+      label: 'Build Profiles',
+      testId: 'menu-build-profiles',
+      execute: () => {
+        openBuildProfilesDocument();
+      },
+    },
+    {
+      id: 'build-output',
+      label: 'Build Output',
+      testId: 'menu-build-output',
+      execute: () => {
+        showBuildOutput();
+      },
+    },
+  ],
+};

package/contributions/build.service.ts

@@ -0,0 +1,31 @@
+/**
+ * THE BUILD FAILURE REVEAL (`workspace.service`) — when a build finishes
+ * FAILED, show the Build output channel so the log that explains it is on screen.
+ * Only actionable failures open a utility automatically, and a build the user
+ * started and that did not produce an artifact is the clearest of them; it
+ * fires on the completing EDGE, never repeatedly.
+ *
+ * It was one of three watchers in the host's `installUtilityAutoOpen`. The
+ * other two (a world that did not mount, a source write that failed) watch
+ * the host's own state and stay there; this one watches THIS package's
+ * session, so it belongs here.
+ */
+import type { ServiceContribution } from '@volter/editor-sdk/services';
+import {
+  getBuildSession,
+  showBuildOutput,
+  subscribeBuildSession,
+} from '../src/build/build-session';
+
+export const point = 'workspace.service';
+
+export const start: ServiceContribution['start'] = () => {
+  let previousPhase = getBuildSession().phase;
+  return subscribeBuildSession(() => {
+    const session = getBuildSession();
+    if (session.phase === 'done' && previousPhase !== 'done' && session.result?.ok === false) {
+      showBuildOutput();
+    }
+    previousPhase = session.phase;
+  });
+};

package/contributions/connection.status.tsx

@@ -0,0 +1,43 @@
+/**
+ * The connection pill in the status bar: `net: <state>` from the inspected
+ * networking adapter, opening the Network inspector on click. Renders
+ * nothing when there is no adapter or no connection-state reader — a pill
+ * claiming "disconnected" for an unmeasured link would be worse than none.
+ */
+
+import { editorHost, useHostAvailabilitySelector } from '@volter/editor-sdk/host';
+import { Button } from '@volter/editor-sdk/widgets';
+import type { ConnectionState } from '@volter/editor-project/adapter';
+
+export const point = 'workspace.status';
+export const title = 'Connection';
+export const align = 'left';
+export const order = 20;
+
+/** The Network inspector's registered utility id (`network.utility.tsx`, under
+ *  the loader's `tool:` namespace). */
+const NETWORK_UTILITY_ID = 'tool:network.utility';
+
+export default function ConnectionStatus() {
+  // Derived off the host's SHARED availability tick; selector-shaped so a
+  // stable connection state re-renders nothing.
+  const state = useHostAvailabilitySelector(
+    (): ConnectionState | null =>
+      editorHost().systems.inspectedNetworking()?.getConnectionState?.() ?? null,
+  );
+  if (state === null) return null;
+  return (
+    <Button
+      type="button"
+      variant="ghost"
+      size="compact"
+      className="vgai-status-action"
+      data-testid="status-connection"
+      data-connection-state={state}
+      onClick={() => editorHost().workspace.showUtility(NETWORK_UTILITY_ID)}
+      title="Network connection state — open Network diagnostics"
+    >
+      net: {state}
+    </Button>
+  );
+}