@almadar/shell-runtime 1.0.0 → 1.1.0

package/dist/{chunk-625EP7W2.js → chunk-2WCVOMZ2.js}

@@ -20,6 +20,9 @@ function headersOf(value) {
   return headers;
 }
 var failed = (kind, op, message) => ({ error: { kind, message: `${op}: ${message}` } });
+var isGpuOp = (op) => op.startsWith("gpu/");
+var noGpu = (op) => failed("unsupported", op, "this host installed no gpu answerer");
+var fetchOnly = (op) => failed("unsupported", op, "a browser host answers only os/fetch, and os/recv and os/close on the handle of a streamed one");
 function createFetchOsHost(performFetch) {
   const pending = /* @__PURE__ */ new Set();
   const bodies = /* @__PURE__ */ new Map();
@@ -57,9 +60,10 @@ function createFetchOsHost(performFetch) {
   }
   return {
     async answer(op, args) {
+      if (isGpuOp(op)) return noGpu(op);
       if (op === "os/recv") return receive(args);
       if (op === "os/close") return release(args);
-      if (op !== "os/fetch") return { error: { kind: "unsupported", message: `${op}: a browser host answers only os/fetch, and os/recv and os/close on the handle of a streamed one` } };
+      if (op !== "os/fetch") return fetchOnly(op);
       const [method, url, request] = args;
       if (typeof method !== "string" || typeof url !== "string") return fail("invalid", "the method and the url must be text");
       if (request !== void 0 && !isRecord(request)) return fail("invalid", "the request must be { headers?, body?, timeoutMs?, stream? }");

package/dist/{chunk-7WB6VWRK.js → chunk-JVSREWQO.js}

@@ -495,7 +495,7 @@ async function withCredentialSegments(ports, op, args, principal) {
 }
 async function osAnswer(ports, request, scope) {
   const { os } = ports;
-  if (os === void 0) return { kind: "os", result: { error: { kind: "denied", message: `${request.op}: no os host configured` } } };
+  if (os === void 0) return { kind: "os", result: { error: { kind: "unsupported", message: `${request.op}: no os host configured` } } };
   const { op, key, site, orbital: asking } = request;
   const completions = ports.osCompletions;
   const sink = ports.deferCallOutcome();
@@ -573,6 +573,37 @@ async function osAnswer(ports, request, scope) {
   }
   return { kind: "os", result: await os.answer(op, args, asking) };
 }
+async function heldGpuAnswer(ports, request, scope) {
+  const held = ports.heldGpu;
+  if (held === void 0) return { kind: "os", result: { error: { kind: "unsupported", message: `${request.op}: this host installed no gpu answerer` } } };
+  const { key } = request;
+  const lease = key === void 0 ? void 0 : ports.inFlightCalls.reserve(key);
+  if (key !== void 0 && lease === void 0) {
+    return { kind: "os", result: { error: { kind: "invalid", message: `${request.op}: key ${key} already has a completion pending` } } };
+  }
+  const answer = await held.answer(request.ticket, (completion) => {
+    const aborted = lease?.signal.aborted === true;
+    lease?.release();
+    if (completion === null) return;
+    const sink = ports.deferCallOutcome();
+    if (aborted || sink === void 0) {
+      held.drop(completion.heldPayload);
+      return;
+    }
+    sink({
+      orbital: completion.orbital ?? scope.orbital,
+      traitName: completion.traitName,
+      event: completion.event,
+      payload: void 0,
+      heldPayload: completion.heldPayload,
+      entityId: completion.entityId,
+      originClientId: scope.originClientId,
+      locale: scope.locale
+    });
+  });
+  if (answer.kind !== "serviceDeferred") lease?.release();
+  return answer;
+}
 async function secret(ports, request) {
   const store = ports.secretPorts?.secrets;
   if (store === void 0) return { kind: "secret", result: { error: SECRET_PORTS_UNAVAILABLE } };
@@ -759,6 +790,8 @@ async function answerRequest(ports, request, scope) {
       return random(ports, request);
     case "os":
       return osAnswer(ports, request, scope);
+    case "gpu":
+      return heldGpuAnswer(ports, request, scope);
     case "clock":
       return { kind: "clock", result: { ok: (ports.now ?? Date.now)() } };
     case "sealed":

package/dist/{chunk-MU335ZA4.js → chunk-OQVSN7DP.js}

@@ -1,6 +1,6 @@
 import { defaultCallService } from './chunk-4SEK5ER2.js';
 import { routeByEntity } from './chunk-O57GKTYU.js';
-import { KernelEngine, evaluateOnKernel } from './chunk-I3TKINSO.js';
+import { KernelEngine, evaluateOnKernel } from './chunk-VKQA2DJX.js';
 import { InFlightCalls } from './chunk-MZKIL5IN.js';
 import { createInProcessTransport } from './chunk-UD2CXYSJ.js';
 import { orbitalInlineEntities, storesRowsInBrowser, inlineTraitRefs } from '@almadar/core';
@@ -33,7 +33,8 @@ function openLocalKernel(options) {
     ...options.secretPorts !== void 0 ? { secretPorts: options.secretPorts } : {},
     ...options.onDevice !== void 0 ? { onDevice: options.onDevice } : {},
     ...options.tabs !== void 0 ? { tabs: options.tabs } : {},
-    ...options.os !== void 0 ? { os: options.os } : {}
+    ...options.os !== void 0 ? { os: options.os } : {},
+    ...options.gpu !== void 0 ? { gpu: options.gpu } : {}
   });
   for (const trait of engine.programSurface().traits) engine.mountClient(LOCAL_CLIENT, trait.orbital, [trait.name]);
   return engine;

package/dist/{chunk-I3TKINSO.js → chunk-VKQA2DJX.js}

@@ -1,6 +1,6 @@
 import { LaneHeldByParkedDispatch } from './chunk-NU6LVKGS.js';
-import { decodeDueTicks, decodeResolveProgress, decodeProgress, decodeNext } from './chunk-X6W44WHO.js';
-import { declareCapabilities, answerRequest } from './chunk-7WB6VWRK.js';
+import { decodeAnswer, decodeHeldCompletion, decodeDueTicks, decodeResolveProgress, decodeProgress, decodeNext } from './chunk-XZGVOBY6.js';
+import { declareCapabilities, answerRequest } from './chunk-JVSREWQO.js';
 import { installKernelEvaluator, LiveBroadcastItemSchema, MountSeedSchema, ExternalInputSchema, NameListSchema, PayloadJsonSchemaSchema, PayloadIssueSchema, InboundOnlySchema, OptionalNameSchema, EntityRowSchema, isEntityReferenceAny, InboundAnswerSchema, EventPayloadSchema, InboundFoundSchema } from '@almadar/core';
 
 var PROGRAM_SURFACE = {
@@ -46,7 +46,15 @@ var KernelEngine = class _KernelEngine {
     this.ports = {
       ...ports,
       substrateMessage: (site, key, value) => JSON.parse(kernel.osCompletionEvent(JSON.stringify({ ...site, emit: { success: site.emit.onMessage } }), key, JSON.stringify({ ok: value }))),
-      substrateCompletion: (site, key, op, args, outcome) => JSON.parse(kernel.substrateCompletionEvent(JSON.stringify(site), key, op, JSON.stringify(args), JSON.stringify(outcome)))
+      substrateCompletion: (site, key, op, args, outcome) => JSON.parse(kernel.substrateCompletionEvent(JSON.stringify(site), key, op, JSON.stringify(args), JSON.stringify(outcome))),
+      ...ports.gpu !== void 0 ? {
+        heldGpu: {
+          answer: async (ticket, completed) => decodeAnswer(await this.handle.answerGpu(ticket, (json) => completed(decodeHeldCompletion(json)))),
+          drop: (heldPayload) => {
+            this.handle.dropHeldPayload(heldPayload);
+          }
+        }
+      } : {}
     };
     this.handle = providedHandle ?? forkedFrom?.fork() ?? this.openServer();
     this.declare();
@@ -78,8 +86,11 @@ var KernelEngine = class _KernelEngine {
     return new _KernelEngine(this.kernel, schemaJson, ports, entityTypes, void 0, this.handle.forkProgram(schemaJson), true);
   }
   /** A server over the host's ports. */
+  /** A server over the host's ports; the host's GPU answerer is installed in it, so it holds every `gpu/` ask. */
   openServer() {
-    return new this.kernel.Server(this.schemaJson, this.lazyDir);
+    const server = new this.kernel.Server(this.schemaJson, this.lazyDir);
+    if (this.ports.gpu !== void 0) server.installGpu(this.ports.gpu);
+    return server;
   }
   declare() {
     const handle = this.handle;

package/dist/{chunk-X6W44WHO.js → chunk-XZGVOBY6.js}

@@ -1,10 +1,17 @@
-import { decodeServerProgressWire, decodeNextWire, decodeResolveProgressWire, decodeFiredTick } from '@almadar/core/kernel-wire';
+import { decodeServerProgressWire, decodeIoAnswerWire, decodeHeldGpuCompletion, decodeNextWire, decodeResolveProgressWire, decodeFiredTick } from '@almadar/core/kernel-wire';
 export { decodeIoRequestWire } from '@almadar/core/kernel-wire';
 
 // src/kernel/decode.ts
 function decodeProgress(json) {
   return decodeServerProgressWire(JSON.parse(json));
 }
+function decodeAnswer(json) {
+  return decodeIoAnswerWire(JSON.parse(json));
+}
+function decodeHeldCompletion(json) {
+  const value = JSON.parse(json);
+  return value === null ? null : decodeHeldGpuCompletion(value);
+}
 function decodeNext(json) {
   const value = JSON.parse(json);
   return value === null ? null : decodeNextWire(value);
@@ -23,4 +30,4 @@ function decodeDueTicks(json) {
   return byOrbital;
 }
 
-export { decodeDueTicks, decodeNext, decodeProgress, decodeResolveProgress };
+export { decodeAnswer, decodeDueTicks, decodeHeldCompletion, decodeNext, decodeProgress, decodeResolveProgress };

package/dist/index.d.ts

@@ -17,16 +17,16 @@ export { InFlightCalls, KeyedCallLease, KeyedCallOutcome, untilAborted } from '.
 export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from './effects/on-device-model.js';
 export { EventBus, createEventBus } from './events/EventBus.js';
 export { StampEmitIdentity, stampEmitSource } from './events/emit-stamp.js';
-export { decodeDueTicks, decodeNext, decodeProgress, decodeResolveProgress } from './kernel/decode.js';
+export { decodeAnswer, decodeDueTicks, decodeHeldCompletion, decodeNext, decodeProgress, decodeResolveProgress } from './kernel/decode.js';
 export { KernelEngine, KernelEvaluation, ProgramlessContract, evaluateOnKernel, kernelRequest } from './kernel/engine.js';
 export { FrameApplied, FrameDispatch, FramePostPort, TickEffects, applyFrame, decodeFrame } from './kernel/frame-applier.js';
-export { DeferredCallOutcome, EventRequestParser, HostAskError, HostAskFailureKind, HostAskOutcome, HostAskReturn, HostAudioAsk, HostConsentAnswer, HostConsentRequest, HostSignInAnswer, HostSignInRequest, KernelAnswerScope, KernelCallService, KernelHostActions, KernelHostPorts, SubstrateStreamSource, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from './kernel/host.js';
+export { DeferredCallOutcome, EventRequestParser, HeldGpuCompletion, HeldGpuPort, HostAskError, HostAskFailureKind, HostAskOutcome, HostAskReturn, HostAudioAsk, HostConsentAnswer, HostConsentRequest, HostSignInAnswer, HostSignInRequest, KernelAnswerScope, KernelCallService, KernelHostActions, KernelHostPorts, SubstrateStreamSource, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from './kernel/host.js';
 export { CredentialAdminPort, CredentialConnectPort, EnvTailsPort, RANDOM_BYTES_MAX, RandomSource, SecretPorts, SecretPortsOptions, SecretStore, SecretStoreHost, base64Standard, base64Url, createBrowserSecretPorts, createCredentialAdminPort, createCredentialConnectPort, createSecretPorts, createSecretStore, credentialForgetPayload, credentialStatusPayload, envTailsOf, randomBytesPayload, systemRandom, userCredentialKey } from './kernel/secret-ports.js';
 export { LaneHeldByParkedDispatch } from './kernel/lane.js';
 export { AnchoredPath, OsAnchorProblem, OsAnchors, OsCompletionEvent, OsCompletionMatchers, OsCompletionPort, OsDesktopKind, OsFsMode, OsGrantKernel, OsGrantMatchers, OsGrantPort, OsHostPort, OsNetKind, OsRequirement, OsStdioKind, OsSysKind, OsTlsKernel, OsTlsPort, OsTlsStep, anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants, kernelOsTls } from './kernel/os-port.js';
 export { createFetchOsHost } from './kernel/os-fetch-port.js';
 export { PROGRAM_EFFECTS, ProgramEffectName, ProgramEffectOutcome, ProgramValidationReport, StepRequest, isProgramEffect } from './kernel/program-effects.js';
-export { FiredByOrbital, KernelModule, KernelServerClass, KernelServerHandle } from './kernel/wire.js';
+export { FiredByOrbital, KernelCanvas3D, KernelCanvas3DFactory, KernelGpuHost, KernelModule, KernelSceneCanvas, KernelSceneCanvasFactory, KernelServerClass, KernelServerHandle } from './kernel/wire.js';
 export { loadLazyPage } from './loader/lazy-page.js';
 export { FetchSchemaLoader } from './loader/fetch-loader.js';
 export { BaseLoaderOptions, ImportChainLike, LoadResult, LoadedOrbital, LoadedSchema, SchemaLoader } from './loader/schema-loader.js';

package/dist/index.js

@@ -1,25 +1,25 @@
 import './chunk-ELBLT2HZ.js';
 export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError } from './chunk-7SDV3QWR.js';
 export { bindDeclaredCollections } from './chunk-BAS26HBN.js';
-export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from './chunk-MU335ZA4.js';
+export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from './chunk-OQVSN7DP.js';
 export { defaultCallService } from './chunk-4SEK5ER2.js';
 export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider } from './chunk-UBN5JJKZ.js';
 export { createResidenceTransport } from './chunk-V4EMDPCO.js';
 export { routeByEntity } from './chunk-O57GKTYU.js';
 export { eventRouteKey } from './chunk-BY5G4225.js';
 import './chunk-LYFIQPXX.js';
-export { createFetchOsHost } from './chunk-625EP7W2.js';
+export { createFetchOsHost } from './chunk-2WCVOMZ2.js';
 export { anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants, kernelOsTls } from './chunk-BOVU4TCQ.js';
 import './chunk-EZZYLTWY.js';
 export { FetchSchemaLoader } from './chunk-57SBCUSM.js';
 export { loadLazyPage } from './chunk-XXWNMJI6.js';
 export { EventBus, createEventBus } from './chunk-SOQDEPME.js';
 export { stampEmitSource } from './chunk-64IH2SMY.js';
-export { KernelEngine, evaluateOnKernel, kernelRequest } from './chunk-I3TKINSO.js';
+export { KernelEngine, evaluateOnKernel, kernelRequest } from './chunk-VKQA2DJX.js';
 export { LaneHeldByParkedDispatch } from './chunk-NU6LVKGS.js';
-export { decodeDueTicks, decodeNext, decodeProgress, decodeIoRequestWire as decodeRequest, decodeResolveProgress } from './chunk-X6W44WHO.js';
+export { decodeAnswer, decodeDueTicks, decodeHeldCompletion, decodeNext, decodeProgress, decodeIoRequestWire as decodeRequest, decodeResolveProgress } from './chunk-XZGVOBY6.js';
 export { applyFrame, decodeFrame } from './chunk-NTFQ36UN.js';
-export { HostAskError, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from './chunk-7WB6VWRK.js';
+export { HostAskError, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from './chunk-JVSREWQO.js';
 export { PROGRAM_EFFECTS, isProgramEffect } from './chunk-WGCWJOT2.js';
 export { RANDOM_BYTES_MAX, base64Standard, base64Url, createBrowserSecretPorts, createCredentialAdminPort, createCredentialConnectPort, createSecretPorts, createSecretStore, credentialForgetPayload, credentialStatusPayload, envTailsOf, randomBytesPayload, systemRandom, userCredentialKey } from './chunk-ZUSM4VW4.js';
 export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from './chunk-FWA5K7Q2.js';

package/dist/kernel/decode.d.ts

@@ -1,4 +1,4 @@
-import { NextWire, ServerProgressWire, ResolveProgressWire } from '@almadar/core/kernel-wire';
+import { IoAnswerWire, HeldGpuCompletion, NextWire, ServerProgressWire, ResolveProgressWire } from '@almadar/core/kernel-wire';
 export { decodeIoRequestWire as decodeRequest } from '@almadar/core/kernel-wire';
 import { FiredByOrbital } from './wire.js';
 import '@almadar/core';
@@ -6,8 +6,10 @@ import '@almadar/core';
 /** Decoders for what the kernel hands back as JSON: the generated decoders of `@almadar/core/kernel-wire`, which throw naming the failing path. */
 
 declare function decodeProgress(json: string): ServerProgressWire;
+declare function decodeAnswer(json: string): IoAnswerWire;
+declare function decodeHeldCompletion(json: string): HeldGpuCompletion | null;
 declare function decodeNext(json: string): NextWire | null;
 declare function decodeResolveProgress(json: string): ResolveProgressWire;
 declare function decodeDueTicks(json: string): FiredByOrbital;
 
-export { decodeDueTicks, decodeNext, decodeProgress, decodeResolveProgress };
+export { decodeAnswer, decodeDueTicks, decodeHeldCompletion, decodeNext, decodeProgress, decodeResolveProgress };

package/dist/kernel/decode.js

@@ -1 +1 @@
-export { decodeDueTicks, decodeNext, decodeProgress, decodeIoRequestWire as decodeRequest, decodeResolveProgress } from '../chunk-X6W44WHO.js';
+export { decodeAnswer, decodeDueTicks, decodeHeldCompletion, decodeNext, decodeProgress, decodeIoRequestWire as decodeRequest, decodeResolveProgress } from '../chunk-XZGVOBY6.js';

package/dist/kernel/engine.d.ts

@@ -55,6 +55,7 @@ declare class KernelEngine {
     fork(ports?: KernelHostPorts): KernelEngine;
     forkProgram(program: OrbitalSchema, ports?: KernelHostPorts): KernelEngine;
     /** A server over the host's ports. */
+    /** A server over the host's ports; the host's GPU answerer is installed in it, so it holds every `gpu/` ask. */
     private openServer;
     private declare;
     /** The contract answers for a host with no program registered yet: the kernel's, asked with no program. */

package/dist/kernel/engine.js

@@ -1,7 +1,7 @@
-export { KernelEngine, evaluateOnKernel, kernelRequest } from '../chunk-I3TKINSO.js';
+export { KernelEngine, evaluateOnKernel, kernelRequest } from '../chunk-VKQA2DJX.js';
 import '../chunk-NU6LVKGS.js';
-import '../chunk-X6W44WHO.js';
-import '../chunk-7WB6VWRK.js';
+import '../chunk-XZGVOBY6.js';
+import '../chunk-JVSREWQO.js';
 import '../chunk-WGCWJOT2.js';
 import '../chunk-ZUSM4VW4.js';
 import '../chunk-FWA5K7Q2.js';

package/dist/kernel/host.d.ts

@@ -3,8 +3,8 @@ import { InFlightCalls } from '../effects/in-flight-calls.js';
 import { ServiceCallContext } from '../service/service-provider.js';
 import { ProgramEffectName, ProgramEffectOutcome } from './program-effects.js';
 import { SecretPorts } from './secret-ports.js';
-import { Settled, EventRequest, CallSiteWire, SubstrateFailureWire, IoRequestWire, IoAnswerWire, OsError } from '@almadar/core/kernel-wire';
-import { KernelModule } from './wire.js';
+import { Settled, EventRequest, CallSiteWire, SubstrateFailureWire, IoAnswerWire, IoRequestWire, OsError } from '@almadar/core/kernel-wire';
+import { KernelGpuHost, KernelModule } from './wire.js';
 import { OsHostPort, OsCompletionPort, OsTlsPort, OsCompletionEvent } from './os-port.js';
 import '../credentials/vault.js';
 
@@ -23,6 +23,8 @@ interface DeferredCallOutcome {
     traitName: string;
     event: string;
     payload: EventPayload | undefined;
+    /** The payload is held in the kernel under this ticket (a `gpu/` completion): the request names it instead of carrying it. */
+    heldPayload?: number;
     entityId: string | undefined;
     originClientId: string | undefined;
     locale: string | undefined;
@@ -147,6 +149,25 @@ interface KernelHostPorts {
     substrateCompletion?: (site: CallSiteWire, key: string, op: string, args: readonly JsonValue[], outcome: Settled<JsonValue, SubstrateFailureWire>) => OsCompletionEvent | null;
     /** The host clock in epoch milliseconds, answering the kernel's `clock` ask; absent, the system clock. */
     now?: () => number;
+    /** The browser's GPU answerer, installed into the kernel: every `gpu/` ask is then held and answered there. */
+    gpu?: KernelGpuHost;
+    /** The GPU answerer installed in the kernel (bound by the engine from `gpu`): it answers a held `gpu` ask by ticket, so its bytes never reach this host. */
+    heldGpu?: HeldGpuPort;
+}
+/** A deferred held `gpu/` ask's completion: the route event and the ticket its payload is held under in the kernel. */
+interface HeldGpuCompletion {
+    orbital?: string;
+    traitName: string;
+    entityId?: string;
+    event: string;
+    heldPayload: number;
+}
+/** The kernel's own GPU answerer (orbital-wasm `Server.answerGpu`), bound to the kernel the host runs. */
+interface HeldGpuPort {
+    /** `completed` runs once for a deferred ask: its completion, or `null` when the outcome takes no declared route. */
+    answer(ticket: number, completed: (completion: HeldGpuCompletion | null) => void): Promise<IoAnswerWire>;
+    /** Drop a held completion payload no request will start. */
+    drop(heldPayload: number): void;
 }
 /** What one dispatch brings to its answers. */
 interface KernelAnswerScope {
@@ -203,4 +224,4 @@ declare function declareCapabilities(persistence: PersistenceAdapter, declare: (
 declare function answerRequest(ports: KernelHostPorts, request: IoRequestWire, scope: KernelAnswerScope): Promise<IoAnswerWire>;
 
 export { HostAskError, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows };
-export type { DeferredCallOutcome, EventRequestParser, HostAskFailureKind, HostAskOutcome, HostAskReturn, HostAudioAsk, HostConsentAnswer, HostConsentRequest, HostSignInAnswer, HostSignInRequest, KernelAnswerScope, KernelCallService, KernelHostActions, KernelHostPorts, SubstrateStreamSource };
+export type { DeferredCallOutcome, EventRequestParser, HeldGpuCompletion, HeldGpuPort, HostAskFailureKind, HostAskOutcome, HostAskReturn, HostAudioAsk, HostConsentAnswer, HostConsentRequest, HostSignInAnswer, HostSignInRequest, KernelAnswerScope, KernelCallService, KernelHostActions, KernelHostPorts, SubstrateStreamSource };

package/dist/kernel/host.js

@@ -1,4 +1,4 @@
-export { HostAskError, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from '../chunk-7WB6VWRK.js';
+export { HostAskError, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from '../chunk-JVSREWQO.js';
 import '../chunk-WGCWJOT2.js';
 import '../chunk-ZUSM4VW4.js';
 import '../chunk-FWA5K7Q2.js';

package/dist/kernel/os-fetch-port.js

@@ -1,3 +1,3 @@
-export { createFetchOsHost } from '../chunk-625EP7W2.js';
+export { createFetchOsHost } from '../chunk-2WCVOMZ2.js';
 import '../chunk-ZUSM4VW4.js';
 import '../chunk-HLOUDLPI.js';

package/dist/kernel/wire.d.ts

@@ -5,8 +5,71 @@ export { CallRoutesWire, CallSiteWire, CallerWire, IoAnswerWire, IoReplyWire, Io
 /** Fired ticks keyed by the orbital that declares them: the one a `runTick` request is addressed to. */
 type FiredByOrbital = FrameWire['fired'];
 
+/** The wasm `GpuHost` (orbital-wasm): the browser's GPU answerer, installed into a kernel `Server` with `installGpu`. */
+interface KernelGpuHost {
+    closeAll(): void;
+}
+/**
+ * The wasm `Canvas3D` (orbital-wasm): orbital-canvas drawing a `canvas mode:"3d"` render node into a page canvas, on
+ * the device the page's `GpuHost` shares. JSON crosses as text; `pointerUp` answers the click it made.
+ */
+interface KernelCanvas3D {
+    /** `themeJson`: the page's resolved canvas theme, or `null`; orbital-canvas reads its scene axis, ground and tones. */
+    setScene(nodeJson: string, themeJson: string): void;
+    resize(cssWidth: number, cssHeight: number, pixelRatio: number): void;
+    setReducedMotion(reduced: boolean): void;
+    render(): void;
+    /** Advances the canvas clock to `nowMs` (`performance.now()`) with the page clock `epochMs` (`performance.timeOrigin + now`), eases a following camera and the orbit damping; true when the frame changed. */
+    frame(nowMs: number, epochMs: number): boolean;
+    /** False on the WebGL2 fallback, where GPU drawables are refused. */
+    webgpu(): boolean;
+    pointerDown(id: number, x: number, y: number, button: number, touch: boolean): void;
+    pointerMove(id: number, x: number, y: number): boolean;
+    pointerLeave(): void;
+    /** `{"unit":{"id","x","z"}}`, `{"tile":{"x","z"}}`, `{"select":{"id"}}`, `{"move":{"id","x","y"}}`, `{"shape":{"id","index"}}` (a learning canvas's click payload) or `null`. */
+    pointerUp(id: number, x: number, y: number, unitEvents: boolean, tileEvents: boolean): string;
+    wheel(deltaY: number): boolean;
+    /** The camera as the user moved it, as JSON, or `null` before a scene. */
+    camera(): string;
+    /** `[x, y, z]` as JSON; true when the camera moved. */
+    setCameraPosition(positionJson: string): boolean;
+    lookAt(targetJson: string): boolean;
+    resetCamera(): boolean;
+    free(): void;
+}
+/**
+ * The wasm `SceneCanvas` (orbital-wasm): orbital-canvas mapping and drawing a canvas-style render node (learning
+ * instruments, diagrams, a 2D game `canvas`) into a page canvas, with its own layout, clock and input.
+ */
+interface KernelSceneCanvas {
+    setScene(nodeJson: string): void;
+    resize(cssWidth: number, cssHeight: number, pixelRatio: number): void;
+    setMotion(enabled: boolean): void;
+    /** Advances the scene clock to `nowMs`; true while the page should keep drawing. */
+    frame(nowMs: number): boolean;
+    render(): void;
+    /** `touch-down`, `touch-move`, `touch-up` or `touch-cancel`, in CSS pixels. */
+    input(kind: string, x: number, y: number, button: number): void;
+    /** Whether the scene took the zoom (a pannable scene); the page scrolls when it did not. */
+    zoom(factor: number, x: number, y: number): boolean;
+    doubleTap(x: number, y: number): void;
+    /** `[{ "event", "payload" }]` queued by input. */
+    takeEvents(): string;
+    webgpu(): boolean;
+    free(): void;
+}
+/** Makes a `SceneCanvas` on a page canvas (`(canvas) => SceneCanvas.create(canvas)` from `@almadar/kernel/client`). */
+type KernelSceneCanvasFactory = (canvas: HTMLCanvasElement) => Promise<KernelSceneCanvas>;
+/** Makes a `Canvas3D` on a page canvas (`(canvas) => Canvas3D.create(canvas)` from `@almadar/kernel/client`). */
+type KernelCanvas3DFactory = (canvas: HTMLCanvasElement) => Promise<KernelCanvas3D>;
 /** The `Server` class of `@almadar/kernel` (wasm-bindgen), as the runtime uses it. */
 interface KernelServerHandle {
+    /** Install the GPU answerer: the server then holds every `gpu/` ask, and the host answers it by ticket. */
+    installGpu(gpu: KernelGpuHost): void;
+    /** Answer the held `gpu` ask `ticket`: the `IoAnswerWire` JSON to reply with. A deferred completion reaches `completed` as `HeldGpuCompletion` JSON, or `null`. */
+    answerGpu(ticket: number, completed: (completionJson: string) => void): Promise<string>;
+    /** Drop a held completion payload no request will start. */
+    dropHeldPayload(ticket: number): boolean;
     start(orbital: string, requestJson: string): string;
     resume(flight: number, repliesJson: string): string;
     /** The oldest request the kernel queued, started now the lane is free: a `NextWire` as JSON, or `null`. */
@@ -101,4 +164,4 @@ interface KernelModule extends KernelEvaluatorExports {
     installLanguage(bundleJson: string): void;
 }
 
-export type { FiredByOrbital, KernelModule, KernelServerClass, KernelServerHandle };
+export type { FiredByOrbital, KernelCanvas3D, KernelCanvas3DFactory, KernelGpuHost, KernelModule, KernelSceneCanvas, KernelSceneCanvasFactory, KernelServerClass, KernelServerHandle };

package/dist/runtime/evaluation/local-store-transport.d.ts

@@ -38,6 +38,8 @@ interface LocalKernelOptions {
     tabs?: BrowserTabPort;
     /** The host's `os` port (`createFetchOsHost` in a browser); absent, every `os` ask is denied. */
     os?: OsHostPort;
+    /** The browser's GPU answerer (the kernel module's `GpuHost`), installed into the kernel; absent, every `gpu/` ask answers `unsupported`. */
+    gpu?: KernelHostPorts['gpu'];
 }
 /** A local store's rows as the kernel holds them: browser-stored entities in `store`, every other entity in `memory` (a native `MemoryStore` adapter). */
 declare function localStorePersistence(schema: OrbitalSchema, store: PersistenceAdapter, memory: PersistenceAdapter): PersistenceAdapter;

package/dist/runtime/evaluation/local-store-transport.js

@@ -1,11 +1,11 @@
-export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from '../../chunk-MU335ZA4.js';
+export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from '../../chunk-OQVSN7DP.js';
 import '../../chunk-4SEK5ER2.js';
 import '../../chunk-UBN5JJKZ.js';
 import '../../chunk-O57GKTYU.js';
-import '../../chunk-I3TKINSO.js';
+import '../../chunk-VKQA2DJX.js';
 import '../../chunk-NU6LVKGS.js';
-import '../../chunk-X6W44WHO.js';
-import '../../chunk-7WB6VWRK.js';
+import '../../chunk-XZGVOBY6.js';
+import '../../chunk-JVSREWQO.js';
 import '../../chunk-WGCWJOT2.js';
 import '../../chunk-ZUSM4VW4.js';
 import '../../chunk-FWA5K7Q2.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/shell-runtime",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "orbRelease": {
     "severity": "normal"
   },
@@ -24,10 +24,10 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@almadar/core": "^11.1.0",
+    "@almadar/core": "^11.3.0",
     "@almadar/kernel": "^19.0.1",
-    "@almadar/logger": "^2.1.0",
-    "@almadar/std": "^17.0.0"
+    "@almadar/logger": "^2.3.0",
+    "@almadar/std": "^17.1.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",