@arcforge/cognet 2.0.146 → 2.0.148

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforge/cognet",
-  "version": "2.0.146",
+  "version": "2.0.148",
   "description": "A cognitive engine",
   "type": "module",
   "private": false,
@@ -17,8 +17,8 @@
     "deploy": "echo \"This package is published ONLY by apps/tui/scripts/release.ts, which pins workspace:* deps to concrete versions first. Publishing it directly ships an unresolvable dependency.\" && exit 1"
   },
   "dependencies": {
-    "@arcforge/err": "2.0.146",
-    "@arcforge/types": "2.0.146",
+    "@arcforge/err": "2.0.148",
+    "@arcforge/types": "2.0.148",
     "hookable": "^5.5.3"
   },
   "devDependencies": {

package/src/host.ts

@@ -133,10 +133,30 @@ function run(code: string | string[]) {
     return kernelOrThrow().run(code)
 }
 
+/**
+ * The `engine` verb, delegating like every other syscall.
+ *
+ * A FACADE rather than a captured reference, for the same reason the rest of
+ * this table delegates: the bound ABI is resolved at the moment a call is
+ * made, never at module scope, so nothing here can outlive or precede a
+ * load(). Written twice-over as one helper because the two facades below
+ * (bound-kernel and ambient) differ only in how they reach the ABI.
+ *
+ * `has` hangs off the callable so the common case reads as one verb and the
+ * degradation check reads as a question — which is the shape the ABI
+ * declares, and a shim that flattened it would quietly change the contract.
+ */
+function engineFacade(resolve: () => KernelAbi): KernelAbi["engine"] {
+    return Object.assign(
+        (role: string) => resolve().engine(role),
+        { has: (role: string) => resolve().engine.has(role) },
+    )
+}
+
 // the syscall table, delegating — live from load() onward
 const localKernel = {
     output: (type: keyof AxonOutputEvent, data: never) => kernelOrThrow().output(type, data),
-    stream: (req: never) => kernelOrThrow().stream(req),
+    engine: engineFacade(() => kernelOrThrow()),
     run,
     scope: () => kernelOrThrow().scope(),
     base: () => kernelOrThrow().base(),
@@ -164,7 +184,6 @@ const localKernel = {
     // A getter, not a captured value: the bound kernel arrives at load(), and
     // capturing this at module scope would freeze an empty map from before
     // the brain was given anything.
-    get models() { return kernelOrThrow().models },
 } satisfies KernelAbi
 
 /**
@@ -193,7 +212,7 @@ const localScope: CognetAmbientScope = scopeFor(null)
 globals.loop = (body: LoopBody): void => ambientOrThrow().loop(body)
 globals.kernel = {
     output: (type: keyof AxonOutputEvent, data: never) => ambientOrThrow().kernel.output(type, data),
-    stream: (req: never) => ambientOrThrow().kernel.stream(req),
+    engine: engineFacade(() => ambientOrThrow().kernel),
     run: ((code: string | string[]) => ambientOrThrow().kernel.run(code as never)) as KernelAbi["run"],
     scope: () => ambientOrThrow().kernel.scope(),
     base: () => ambientOrThrow().kernel.base(),
@@ -216,7 +235,6 @@ globals.kernel = {
     // that outlives each wake, which is exactly what a driver needs.
     wake: () => kernelOrThrow().wake(),
     clock: () => kernelOrThrow().clock(),
-    get models() { return kernelOrThrow().models },
 } satisfies KernelAbi
 
 globals.phase = <T>(name: string, fn: () => Promise<T>) => ambientOrThrow().phase(name, fn)