toilscript 0.1.44 → 0.1.45

package/dist/importmap.json

@@ -1,7 +1,7 @@
 {
   "imports": {
-    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.44/dist/toilscript.js",
-    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.44/dist/cli.js",
+    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.45/dist/toilscript.js",
+    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.45/dist/cli.js",
     "binaryen": "https://cdn.jsdelivr.net/npm/binaryen@130.0.0-nightly.20260609/index.js",
     "long": "https://cdn.jsdelivr.net/npm/long@5.3.2/index.js"
   }

package/dist/toilscript.generated.d.ts

@@ -2972,6 +2972,8 @@ declare module "types:toilscript/src/parser" {
         dependees: Map<string, Dependee>;
         /** Normalized paths whose `@rest` runtime import has already been injected. */
         restImportedSources: Set<string>;
+        /** Normalized paths whose `@service`/`@remote` RPC runtime import has already been injected. */
+        rpcImportedSources: Set<string>;
         /** Normalized paths whose `@stream` module-level registry + the single
          *  `stream_dispatch` export have already been emitted (a project may declare
          *  several `@stream` classes, but the export is emitted exactly once). */
@@ -3105,6 +3107,41 @@ declare module "types:toilscript/src/parser" {
          * return; plus a module-level self-registration into the runtime `Rest` router.
          */
         private injectRestController;
+        /**
+         * Wire a `@service` class's `@remote` methods onto the global `Rpc` registry - the RPC mirror of
+         * `injectRestController`. Each method becomes an id-matched arm of a synthesized
+         * `__rpcDispatch(__id, __body)`: decode the positional args from the body, call the method on a FRESH
+         * instance (stateless, exactly like a `@rest` controller), encode the result. The id is FNV-1a of
+         * `"Class.method"` - the identical hash the generated client sends in the `toil-rpc` header, so the
+         * wire matches without the two sides sharing state. `DataReader`/`DataWriter` are ambient (std).
+         */
+        private injectService;
+        /** True if a return type node is `void` (no result is encoded). */
+        private rpcIsVoid;
+        /** AS statements decoding one RPC arg of `typeNode` from `__r` into a fresh const `dest` (mirrors the
+         *  per-field decode in `injectDataCodec`: length-prefixed array, raw bytes, or scalar/@data). */
+        private rpcDecodeArg;
+        /** AS statements encoding the result `src` of `typeNode` into `__w`; `void` -> "" (mirrors the
+         *  per-field encode in `injectDataCodec`). */
+        private rpcEncodeResult;
+        /**
+         * Wire `@service` classes and free `@remote` functions onto the global `Rpc` registry. Runs ONCE
+         * before element creation (via `weaveDataMigrations`). `@service` could be done at parse time, but
+         * folding both here gives a SINGLE place to honor the `@stream` gating: a project using `@stream`
+         * cannot declare `@service`/`@remote` (the 9003 diagnostic fires at element creation), so we must not
+         * half-inject first or the build crashes instead of reporting it.
+         */
+        private weaveRpc;
+        /** Reject duplicate client-facing `Server` keys (two @services lowercasing to the same key, a free
+         *  @remote shadowing a @service / the reserved REST / Stream) and FNV method-id collisions, before the
+         *  surface is emitted - else the generated `Server` object/type silently overwrites a key, or a collided
+         *  id routes to the wrong method at dispatch. */
+        private checkRpcSurfaceCollisions;
+        /** True if the program declares any `@stream` class (gates the RPC weave; see diagnostic 9003). */
+        private projectHasStream;
+        /** Inject the RPC dispatch fn + its registration for one free `@remote` function (id = FNV of the
+         *  bare function name, matching the generated client). */
+        private injectRemote;
         /**
          * Synthesize the cold-artifact daemon entry for a `@daemon` class (spec 03
          * sections 5.2 / 5.6 / 5.7, Reconciliation Part 2 cold exports). Mirrors
@@ -3152,8 +3189,8 @@ declare module "types:toilscript/src/parser" {
          *       order), switches on `event_kind` (1 connect / 2 message / 3 close /
          *       4 disconnect, the FIXED Part 2 ABI values), and returns the hook's
          *       packed-i64 result (0 = no output / accept; a negative value is the
-         *       Part 3 reject/error bridge, wired with the real ring/StreamOutbound
-         *       runtime in a later increment).
+         *       Part 3 reject/error bridge `-(0x10000 + 0x02xx)`, lowered through the
+         *       real ring/StreamOutbound runtime via `__encode`).
          *
          * Each `@stream` class keeps its own MODULE-SINGLETON instance (a resident
          * per-connection box): the dispatch thunk constructs it on first use and REUSES
@@ -3181,13 +3218,14 @@ declare module "types:toilscript/src/parser" {
          *
          * Only hooks the class actually declares get a dispatch arm; an event for an
          * absent hook falls through to `return 0` (a no-op success per the contract,
-         * never a crash). A hook that declares parameters (the typed `@message`
-         * `@data` arg, or a `StreamInbound`/`StreamPacket` view) is given a no-op arm
-         * here too: the `StreamInbound`/`StreamPacket`/`StreamOutbound` runtime + the
-         * ingress-ring read are owned by toiljs (spec 5.4) and land in a later
-         * increment, so this self-contained shim cannot synthesize those argument
-         * values yet; calling a zero-arg hook directly is the part that compiles and
-         * runs today (every gating/catalog fixture uses the zero-arg/void hook form).
+         * never a crash). Param'd hooks are fully wired through the injected ring
+         * runtime (`streamRuntimeSource`): `@connect(StreamInbound)` reads the host's
+         * connect-info block, `@message(StreamPacket)` drains the raw ingress frame, and
+         * `@message(MessageType)` decodes the frame into the `@data` class declared by
+         * `@stream({ message: MessageType })` (doc 03 2.5); each may reply with a
+         * `StreamOutbound` (lowered via `__encode`) or return `void`. An unrecognized
+         * `@message` / `@connect` signature is a hard error (9015 / 9014), never a
+         * silent no-op.
          *
          * Fires the 9013 warning for a `@stream` class with zero lifecycle hooks (a
          * hookless stream can never receive traffic), mirroring the daemon 9008 warning
@@ -4564,6 +4602,21 @@ declare module "types:toilscript/src/dbcatalog" {
      *      str route_pattern  (same normalized pattern emitted into __toilMatch)
      */
     export function buildToilDbRouteKinds(program: Program): Uint8Array | null;
+    /** Build the `toildb.rpc_kinds` section bytes, or `null` when no @remote needs the Action upgrade.
+     *  Unlike `route_kinds` (a DOWNGRADE list of explicit `@query` routes, with POST defaulting to Action),
+     *  an RPC method has no HTTP-method signal and defaults to READ-ONLY (Query). This section is therefore
+     *  the inverse - an UPGRADE list: the FNV ids of the `@action` `@remote`s the runtime must let WRITE.
+     *  Everything else (a plain `@remote` or an explicit `@query`) stays Query, so a read-only RPC can never
+     *  silently mutate the DB.
+     *
+     *  Wire format (LE):
+     *    u16 format_version = 1
+     *    u16 n_methods
+     *    per method:
+     *      u32 method_id      (FNV-1a of "ClassName.methodName" or "fnName", the `toil-rpc` header id)
+     *      u8  function_kind  (1 = Action)
+     */
+    export function buildToilDbRpcKinds(program: Program): Uint8Array | null;
     /** Build the `toilstream.catalog` section bytes, or `null` if the program
      *  declares no `@stream` class. Per Part 5 (LE):
      *