@threenative/core 0.3.2 → 0.3.4

package/dist/playtest.d.ts

@@ -1,10 +1,10 @@
 import { JsonValue, JsonPrimitive } from '@threenative/playtest/protocol';
-import { b as IGamePluginHooks } from './game-XGrTzapq.js';
-import './assets-kyoF7JlJ.js';
+import { b as IGamePluginHooks } from './game-CljaDv4D.js';
+import './assets-CqvE429w.js';
 import 'three';
-import './renderer-C6hqZpoG.js';
+import './renderer-CfsS2hxi.js';
 import 'three/webgpu';
-import './canvas-layer-BLVijiUJ.js';
+import './canvas-layer-DDmC_VVF.js';
 import 'zustand/vanilla';
 
 /**
@@ -31,6 +31,12 @@ declare const PLAYTEST_ATTACH_TIMEOUT_MS = 30000;
  */
 /** The global a playtest runner sets before the page loads, so a game can tell one is coming. */
 declare const PLAYTEST_RUNNER_EXPECTED_GLOBAL = "__THREENATIVE_PLAYTEST_RUNNER_EXPECTED__";
+/**
+ * The clock a consumer asks this game to run on, named in the protocol's own vocabulary. Set before
+ * the game module evaluates — a production profile does it in the instrumentation it injects ahead
+ * of the bundle, on the browser and on native alike.
+ */
+declare const PLAYTEST_CLOCK_GLOBAL = "__THREENATIVE_PLAYTEST_CLOCK__";
 interface IPlaytestOptions {
     readonly events?: () => JsonValue[];
     /**
@@ -63,4 +69,4 @@ interface IPlaytestTransition {
     to: JsonPrimitive;
 }
 
-export { type IPlaytestOptions, type IPlaytestTransition, PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };
+export { type IPlaytestOptions, type IPlaytestTransition, PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_CLOCK_GLOBAL, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };

package/dist/playtest.js

@@ -1,27 +1,48 @@
 import { assertJsonSafe, PLAYTEST_PROTOCOL_LIMITS } from '@threenative/playtest/protocol';
 import { installThreePlaytestBridge } from '@threenative/playtest/three';
-import { Object3D } from 'three';
+import { Sphere, Vector3, Object3D } from 'three';
 
 // src/playtest.ts
-var buses = /* @__PURE__ */ new Set();
+var AUDIO_STATE = /* @__PURE__ */ Symbol.for("threenative.audio.runtime");
+function audioState() {
+  const host = globalThis;
+  const existing = host[AUDIO_STATE];
+  if (existing !== void 0) return existing;
+  const created = { buses: /* @__PURE__ */ new Set(), cueCounts: /* @__PURE__ */ new Map(), cueLog: [] };
+  host[AUDIO_STATE] = created;
+  return created;
+}
 function audioRuntimeSnapshot() {
   let queued = 0;
   let voices = 0;
   let pooled = 0;
   let paused = 0;
   const unsupported = /* @__PURE__ */ new Set();
-  for (const bus of buses) {
+  const state = audioState();
+  for (const bus of state.buses) {
     queued += bus.queued;
     voices += bus.voices;
     pooled += bus.pooled;
     paused += bus.pausedVoices;
     for (const option of bus.unsupported) unsupported.add(option);
   }
-  return { paused, pooled, queued, unsupported: [...unsupported].sort(), voices };
+  return {
+    cues: Object.fromEntries(state.cueCounts),
+    paused,
+    pooled,
+    queued,
+    recentCues: state.cueLog.map((entry) => ({ ...entry })),
+    unsupported: [...unsupported].sort(),
+    voices
+  };
 }
+var GEOMETRY_CAPTURE_CAPABILITY = "runtime.geometry";
+new Sphere();
+new Vector3();
+new Vector3();
 
 // src/version.ts
-var CORE_VERSION = "0.3.2";
+var CORE_VERSION = "0.3.4";
 
 // src/pipeline-census.ts
 var PIPELINE_CENSUS_CAPABILITY = "runtime.pipelineCensus";
@@ -53,6 +74,7 @@ function playtest(options = {}) {
   let attached;
   let startSceneEntered;
   let disposePipelineCensus;
+  let disposeGeometryCapture;
   let contactHistory = [];
   const watcher = createTransitionWatcher();
   let readTick;
@@ -70,6 +92,8 @@ function playtest(options = {}) {
     setup: async (ctx, runtime) => {
       readTick = runtime?.tick;
       const seed = runtime?.seed ?? null;
+      const clockMode = requestedClockMode();
+      const wallClock = clockMode === "wall-clock";
       const replayRuntime = runtime?.seed === null || runtime?.seed === void 0 ? void 0 : {
         agent: currentAgent,
         core: CORE_VERSION,
@@ -79,9 +103,15 @@ function playtest(options = {}) {
       };
       const installation = installThreePlaytestBridge({
         camera: ctx.camera,
+        ...clockMode === void 0 ? {} : { clockMode },
         entities: () => bridgeEntities(ctx),
         components: () => componentObservations(ctx.entities.snapshot()),
-        ...runtime === void 0 ? {} : { fixedStep: runtime.fixedStep, tick: runtime.tick },
+        // The live clock has to be driven by the host's own frame pump, so a live run's `advance`
+        // waits the span of wall time the count names and reports the ticks that pump ran.
+        ...runtime === void 0 ? {} : {
+          fixedStep: wallClock ? wallClockAdvance(runtime) : runtime.fixedStep,
+          tick: runtime.tick
+        },
         ...runtime?.runtimeDiagnosticsSeries === void 0 ? {} : { runtimeDiagnosticsSeries: runtime.runtimeDiagnosticsSeries },
         ...options.events === void 0 ? {} : { events: options.events },
         gameplay: () => gameplayObservations(ctx, contactHistory, seed, replayRuntime, watcher),
@@ -122,14 +152,27 @@ function playtest(options = {}) {
           sample: () => ({ pipelineCensus: pipelineCensus() })
         });
       }
+      const geometryCapture = runtime?.geometryCapture;
+      if (runtime !== void 0 && geometryCapture !== void 0) {
+        disposeGeometryCapture = runtime.observations.contribute({
+          capabilities: [GEOMETRY_CAPTURE_CAPABILITY],
+          // Nothing is armed, walked or hooked unless this request asked for a capture: the
+          // capability says the runtime can answer, not that every sample pays for one.
+          sample: async (request) => request.geometry === void 0 ? {} : { geometry: await geometryCapture(request.geometry) }
+        });
+      }
       installRuntimeChannels(installation.bridge, runtime);
-      if (globalThis[PLAYTEST_RUNNER_EXPECTED_GLOBAL] === true)
+      if (runnerAnnounced()) {
         runtime?.enableRuntimeDiagnostics?.();
+        if (!wallClock) runtime?.freezeClock?.();
+      }
       dispose = installation.dispose;
       attached = holdUntilAttached(installation.bridge, options, () => startSceneEntered);
       const cleanup = () => {
         disposePipelineCensus?.();
         disposePipelineCensus = void 0;
+        disposeGeometryCapture?.();
+        disposeGeometryCapture = void 0;
         dispose?.();
         dispose = void 0;
         attached = void 0;
@@ -155,8 +198,32 @@ function playtest(options = {}) {
 }
 var PLAYTEST_ATTACH_TIMEOUT_MS = 3e4;
 var PLAYTEST_RUNNER_EXPECTED_GLOBAL = "__THREENATIVE_PLAYTEST_RUNNER_EXPECTED__";
+var PLAYTEST_CLOCK_GLOBAL = "__THREENATIVE_PLAYTEST_CLOCK__";
+function requestedClockMode() {
+  const requested = globalThis[PLAYTEST_CLOCK_GLOBAL];
+  if (requested === void 0) return void 0;
+  if (requested === "wall-clock") return "wall-clock";
+  throw new Error(
+    `TN_PLAYTEST_CLOCK_UNSUPPORTED: '${PLAYTEST_CLOCK_GLOBAL}' is ${JSON.stringify(requested)}; this protocol knows 'wall-clock' and nothing else.`
+  );
+}
+var WALL_CLOCK_PUMP_STEPS = 4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function wallClockAdvance(runtime) {
+  const stepMs = runtime.step * 1e3;
+  return async (ticks) => {
+    const before = runtime.tick();
+    await sleep(ticks * stepMs);
+    for (let waited = 0; waited < WALL_CLOCK_PUMP_STEPS && runtime.tick() === before; waited += 1)
+      await sleep(stepMs / 2);
+    return runtime.tick() - before;
+  };
+}
 function shouldHoldUntilAttached(options) {
   if (options.holdUntilAttached !== void 0) return options.holdUntilAttached;
+  return runnerAnnounced();
+}
+function runnerAnnounced() {
   const host = globalThis;
   return host[PLAYTEST_RUNNER_EXPECTED_GLOBAL] === true || host.TN_PLAYTEST_ENDPOINT !== void 0;
 }
@@ -227,10 +294,10 @@ function addRuntimeCapabilities(description, contributions) {
   }
   return { ...description, capabilities };
 }
-function addRuntimeObservations(snapshot, request, contributions) {
+async function addRuntimeObservations(snapshot, request, contributions) {
   const result = { ...snapshot };
   for (const contribution of contributions) {
-    const slice = contribution.sample(request);
+    const slice = await contribution.sample(request);
     if (typeof slice !== "object" || slice === null || Array.isArray(slice)) {
       throw new TypeError("A runtime observation contribution must return a top-level object.");
     }
@@ -434,11 +501,29 @@ function stateResources(ctx) {
         // `state` is canonical. Keep `GameState` as a compatibility alias until published
         // scenarios have migrated, then remove the alias in a future breaking release.
         ["state", value],
-        ["GameState", value]
+        ["GameState", value],
+        // Where every asset was actually served from, on every target and not only in a browser
+        // console log: a game whose manifest never loaded runs on the uncompiled source directory
+        // and looks healthy, and without this nothing observable says so.
+        ["assets", assetResolutions(ctx.assets)]
       ]);
     }
   };
 }
+function assetResolutions(assets) {
+  const nested = {};
+  for (const [logical, record] of assets.resolved) {
+    const parts = logical.split(".");
+    let node = nested;
+    for (const part of parts.slice(0, -1)) {
+      const child = node[part] ?? {};
+      node[part] = child;
+      node = child;
+    }
+    node[parts.at(-1) ?? logical] = { url: record.url, via: record.via };
+  }
+  return nested;
+}
 function cloneJsonValue(value) {
   if (Array.isArray(value)) return value.map((item) => cloneJsonValue(item));
   if (typeof value === "object" && value !== null) {
@@ -449,4 +534,4 @@ function cloneJsonValue(value) {
   return value;
 }
 
-export { PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };
+export { PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_CLOCK_GLOBAL, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };

package/dist/react.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
-import { C as CanvasLayer } from './canvas-layer-BLVijiUJ.js';
+import { C as CanvasLayer } from './canvas-layer-DDmC_VVF.js';
 import 'three';
-import './renderer-C6hqZpoG.js';
+import './renderer-CfsS2hxi.js';
 import 'three/webgpu';
 
 /**