toilscript 0.1.38 → 0.1.41

package/dist/web.js

@@ -1,8 +1,8 @@
-var ASSEMBLYSCRIPT_VERSION = "0.1.38";
+var ASSEMBLYSCRIPT_VERSION = "0.1.41";
   var ASSEMBLYSCRIPT_IMPORTMAP = {
   "imports": {
-    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.38/dist/toilscript.js",
-    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.38/dist/cli.js",
+    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.41/dist/toilscript.js",
+    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.41/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/package.json

@@ -8,7 +8,7 @@
     "toilscript",
     "wasm"
   ],
-  "version": "0.1.38",
+  "version": "0.1.41",
   "author": "Daniel Wirtz <dcode+assemblyscript@dcode.io>",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dacely-cloud/toilscript",
@@ -80,7 +80,7 @@
     "prepublishOnly": "node scripts/build",
     "watch": "node scripts/build --watch",
     "coverage": "npx c8 -- npm test",
-    "test": "npm run test:parser && npm run test:compiler -- --parallel && npm run test:browser && npm run test:toilconfig && npm run test:transform && npm run test:cli && npm run test:json && npm run test:data && npm run test:dbstatic",
+    "test": "npm run test:parser && npm run test:compiler -- --parallel && npm run test:browser && npm run test:toilconfig && npm run test:transform && npm run test:cli && npm run test:json && npm run test:data && npm run test:dbresolve && npm run test:dbstatic && npm run test:routekinds && npm run test:streams",
     "test:parser": "node --enable-source-maps tests/parser",
     "test:compiler": "node --enable-source-maps --no-warnings tests/compiler",
     "test:browser": "node --enable-source-maps tests/browser",
@@ -91,7 +91,10 @@
     "test:cli": "node tests/cli/options.js",
     "test:json": "node tests/json/run.mjs",
     "test:data": "node tests/data/run.mjs",
+    "test:dbresolve": "node tests/dbresolve/run.mjs",
     "test:dbstatic": "node tests/dbstatic/run.mjs",
+    "test:routekinds": "node tests/routekinds/run.mjs",
+    "test:streams": "node tests/streams/run.mjs && node tests/streams/catalog.mjs && node tests/streams/codegen.mjs",
     "asbuild": "npm run asbuild:debug && npm run asbuild:release",
     "asbuild:debug": "node bin/toilscript --config src/toilconfig.json --target debug",
     "asbuild:release": "node bin/toilscript --config src/toilconfig.json --target release",

package/std/assembly/bindings/toildb.ts

@@ -35,8 +35,9 @@ export namespace toildbHost {
   export declare function get(handle: u32, keyPtr: usize, keyLen: i32): i32;
 
   // record bounded multi-get. Input at keysPtr: u32 count + per key (u32 len +
-  // bytes). Result (stashed): u32 count + per item u8 present (+ u32 len + bytes
-  // when present), in request order. Returns the stashed length | negative error.
+  // bytes). Result (stashed): u32 count + per item u8 present, and when present
+  // `u32 schema_version + u32 len + bytes`, in request order. Returns the
+  // stashed length | negative error.
   // @ts-ignore: decorator
   @external("env", "data.get_many")
   export declare function getMany(handle: u32, keysPtr: usize, keysLen: i32): i32;
@@ -148,7 +149,7 @@ export namespace toildbHost {
   ): i32;
 
   // membership.list(limit) -> framed-list length (stashed) | negative error.
-  // The blob is `u32 count` then per member `u32 len + bytes`.
+  // The blob is `u32 count` then per member `u32 schema_version + u32 len + bytes`.
   // @ts-ignore: decorator
   @external("env", "data.membership_list")
   export declare function membershipList(handle: u32, setPtr: usize, setLen: i32, limit: i32): i32;
@@ -216,7 +217,8 @@ export namespace toildbHost {
   ): i32;
 
   // events.latest(limit) -> framed-list length (stashed) | negative error.
-  // The blob is `u32 count` then per event `u32 len + bytes`, newest first.
+  // The blob is `u32 count` then per event `u32 schema_version + u32 len + bytes`,
+  // newest first.
   // @ts-ignore: decorator
   @external("env", "data.latest")
   export declare function latest(handle: u32, keyPtr: usize, keyLen: i32, limit: i32): i32;

package/std/assembly/toildb.ts

@@ -21,7 +21,8 @@ import { DataWriter } from "data";
 export function __toildbResolve(name: string): u32 {
   const nb = Uint8Array.wrap(String.UTF8.encode(name));
   const out = new Uint8Array(4);
-  toildbHost.resolveCollection(nb.dataStart, nb.byteLength, out.dataStart);
+  const status = toildbHost.resolveCollection(nb.dataStart, nb.byteLength, out.dataStart);
+  if (status < 0) abort("ToilDB collection resolve failed", "toildb", 0, 0);
   return load<u32>(out.dataStart);
 }
 
@@ -470,7 +471,8 @@ export class Events<K, V> {
   }
 
   /// The newest `limit` events, newest first. Decodes each framed event into a
-  /// `V`. The host frames them as `u32 count` then per event `u32 len + bytes`.
+  /// `V`. The host frames them as `u32 count` then per event
+  /// `u32 schema_version + u32 len + bytes`.
   latest(key: K, limit: i32): V[] {
     const kb = key.encode();
     const status = toildbHost.latest(this.__handle, kb.dataStart, kb.byteLength, limit);

package/std/assembly/toilscript.d.ts

@@ -85,6 +85,106 @@ declare function auth(target: Object, propertyKey: string | symbol, descriptor:
 /** Declare the authenticated-user type (`@user class User { ... }`); enables `AuthService.getUser()`. */
 declare function user(target: Function): void;
 
+// --- L4 daemon (@daemon / @scheduled) + streams (@stream + lifecycle hooks),
+//     handled natively by the compiler; typed here so editors accept the bare forms ---
+
+/** Marks the single L4 daemon class: instantiated once on the global cold box,
+ *  its instance fields preserved for the box lifetime. At most one `@daemon` per
+ *  project. May declare a zero-arg `onStart(): void`, run once at boot. Cold
+ *  artifact only (a `@daemon` is a compile error in the hot/request build). */
+declare function daemon(target: Function): void;
+
+/** Declares a `@daemon` method as a scheduled task fired on each due tick. `spec`
+ *  is an interval (`"30s"` / `"5m"` / `"1h"` / `"1d"`) or a 5-field cron string
+ *  (e.g. `"15 9 * * 1-5"`, weekdays 9:15). The handler must be `(): void` (no parameters, no return). */
+declare function scheduled(spec: string): (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => void;
+
+/** Stream placement scope for `@stream({ scope })`: `Regional` (0, L2) or
+ *  `Continental` (1, L3). Values match the runtime stream codec. */
+declare enum StreamScope { Regional, Continental }
+
+/** Optional `@stream` config object. Set `message` to a `@data` class to receive
+ *  decoded packets; omit it for the raw-bytes default (`StreamPacket`). */
+interface StreamOptions {
+  scope?: StreamScope;
+  message?: Function;
+  maxFrameBytes?: i32;
+  ingressRingBytes?: i32;
+}
+
+/** Marks a class as a stream protocol handler (runs on L2/L3 nodes). Its
+ *  `@connect`/`@message`/`@close`/`@disconnect`/`@channel` methods are the
+ *  lifecycle hooks. A project that uses `@stream` may NOT declare any `@service`
+ *  or `@remote` anywhere (compiler-enforced). Hot/stream artifact only.
+ *
+ *  Three forms (mirroring `@rest`): bare `@stream` (the routing name is the class
+ *  name), `@stream("name")` (an explicit mount name / routing key, e.g. `/name`),
+ *  or `@stream({ scope, message, ... })` for the full config object. */
+declare function stream(target: Function): void;
+declare function stream(name?: string): (target: Function) => void;
+declare function stream(options: StreamOptions): (target: Function) => void;
+
+/** Stream lifecycle-hook method decorators on a `@stream` class. `@connect` runs
+ *  on open (returns `StreamOutbound`); `@message` handles an inbound packet;
+ *  `@close` is a graceful close; `@disconnect` is an abrupt transport loss;
+ *  `@channel` receives an opt-in fanned-out channel message. */
+declare function connect(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>): void;
+declare function message(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>): void;
+declare function close(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>): void;
+declare function disconnect(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>): void;
+declare function channel(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>): void;
+
+// Stream handler argument/return types. Ambient (like the bignum natives below):
+// the compiler/runtime provides the real classes; declared here so `@stream`
+// handler signatures type-check in any editor.
+
+/** The connection-open context passed to `@connect`. Read-only. */
+declare class StreamInbound {
+  get connectionId(): u64;
+  get streamName(): string;
+  get remoteIp(): string;
+  get path(): string;
+  header(name: string): string;
+}
+
+/** The accept/reject + optional first-frame decision returned by
+ *  `@connect` / `@message`. */
+declare class StreamOutbound {
+  static accept(): StreamOutbound;
+  static reply(body: Uint8Array): StreamOutbound;
+  static reject(reason: u16): StreamOutbound;
+  static empty(): StreamOutbound;
+}
+
+/** The close context passed to `@close` (a graceful or host-initiated close,
+ *  distinct from `@disconnect`). */
+declare class StreamConnectionEvent {
+  get connectionId(): u64;
+  get reason(): u16;
+  get durationMs(): u64;
+}
+
+/** The default (raw-bytes) `@message` parameter: a thin view over the host
+ *  ingress ring. The ring slot is reused after the hook returns, so copy via
+ *  `bytes()` to retain. */
+declare class StreamPacket {
+  get connectionId(): u64;
+  get length(): i32;
+  bytes(): Uint8Array;
+  at(i: i32): u8;
+}
+
+/** The fanned-out channel message passed to `@channel`: the channel name plus
+ *  the raw published bytes (no decode). */
+declare class StreamChannelMessage {
+  get connectionId(): u64;
+  get channelHash(): u32;
+  get channelName(): string;
+  get length(): i32;
+  bytes(): Uint8Array;
+  at(i: i32): u8;
+}
+
 // --- ToilDB (@database / @collection + the @query/@action/... function kinds),
 //     handled natively by the compiler; typed here so editors accept the bare forms ---
 
@@ -92,6 +192,13 @@ declare function user(target: Function): void;
  *  lazily-resolved collection handle (`App.users.get(...)`). */
 declare function database(target: Function): void;
 
+declare interface CollectionOptions {
+  fillMaxWaitMs?: i32;
+  maxWaitMs?: i32;
+  fillStale?: string;
+  stale?: string;
+}
+
 /** Declares a `@database` field as a collection - a `Documents`/`View`/`Unique`/
  *  `Counter`/`Events`/`Membership`/`Capacity` handle. Prefer the `static` form,
  *  `@collection static users: Documents<UserId, User>` (no `!` - a definite
@@ -101,6 +208,7 @@ declare function database(target: Function): void;
  *  still works but needs the toilscript TS plugin to type the static `App.users`
  *  access. */
 declare function collection(target: Object, propertyKey: string | symbol): void;
+declare function collection(options: CollectionOptions): (target: Object, propertyKey: string | symbol) => void;
 
 /** ToilDB function kinds (spec 6) - the data ops a function may issue. `@query`
  *  is read-only; `@action` adds bounded writes/claims; `@derive` publishes