toilscript 0.1.35 → 0.1.37

package/dist/web.js

@@ -1,8 +1,8 @@
-var ASSEMBLYSCRIPT_VERSION = "0.1.35";
+var ASSEMBLYSCRIPT_VERSION = "0.1.37";
   var ASSEMBLYSCRIPT_IMPORTMAP = {
   "imports": {
-    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.35/dist/toilscript.js",
-    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.35/dist/cli.js",
+    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.37/dist/toilscript.js",
+    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.37/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.35",
+  "version": "0.1.37",
   "author": "Daniel Wirtz <dcode+assemblyscript@dcode.io>",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dacely-cloud/toilscript",

package/std/assembly/bindings/dom.ts

@@ -134,7 +134,7 @@ export declare namespace Object {
 
 export declare namespace Date {
   @external("env", "Date.now")
-  export function now(): f64;
+  export function now(): u64;
 }
 
 export declare namespace console {

package/std/assembly/bindings/toildb.ts

@@ -221,6 +221,33 @@ export namespace toildbHost {
   @external("env", "data.latest")
   export declare function latest(handle: u32, keyPtr: usize, keyLen: i32, limit: i32): i32;
 
+  // events.append_once -> 1 appended | 0 duplicate (deduped on eventId) | <0 error.
+  // Idempotent append: a retried call with the same eventId never doubles the event.
+  // @ts-ignore: decorator
+  @external("env", "data.append_once")
+  export declare function appendOnce(
+    handle: u32,
+    keyPtr: usize,
+    keyLen: i32,
+    evidPtr: usize,
+    evidLen: i32,
+    evPtr: usize,
+    evLen: i32
+  ): i32;
+
+  // records.enqueue -> 0 ok | <0 error (Conflict if a concurrent write won, NotFound
+  // if absent). A version-checked replace of an existing record's value.
+  // @ts-ignore: decorator
+  @external("env", "data.enqueue")
+  export declare function enqueue(
+    handle: u32,
+    keyPtr: usize,
+    keyLen: i32,
+    valPtr: usize,
+    valLen: i32,
+    idemPtr: usize
+  ): i32;
+
   // Copy the last stashed variable-length result into outPtr (outLen must equal
   // the length the producing op returned). Returns bytes written, or -1 if the
   // buffer is too small.

package/std/assembly/date.ts

@@ -37,8 +37,8 @@ export class Date {
     return ms;
   }
 
-  @inline static now(): i64 {
-    return <i64>Date_binding.now();
+  @inline static now(): u64 {
+    return Date_binding.now();
   }
 
   // It can parse only ISO 8601 inputs like YYYY-MM-DDTHH:MM:SS.000Z

package/std/assembly/index.d.ts

@@ -2231,7 +2231,7 @@ declare class Date {
     millisecond: i32
   ): i64;
   /** Returns the current UTC timestamp in milliseconds. */
-  static now(): i64;
+  static now(): u64;
   /** Parses a string representation of a date, and returns the number of milliseconds since January 1, 1970, 00:00:00 UTC. */
   static parse(dateString: string): Date;
   static fromString(dateString: string): Date;

package/std/assembly/toildb.ts

@@ -38,7 +38,14 @@ export function __toildbReadVersion(): i64 {
 /// before each decode and reads it after; the dispatch marks it AFTER the
 /// transform runs, so a transform that itself reads (resetting the flag) does not
 /// clear the outer migration.
-let __toildbMigratedFlag: bool = false;
+// `@lazy`: initialized on first access rather than in module-init order. A value
+// type's woven `decodeInto` (which, under the cross-file `@migrate` convention,
+// lives in a DIFFERENT module than this one) compiles these exported accessors on
+// demand; @lazy breaks the init-order dependency so that never trips a
+// use-before-declaration that a plain global would in that circular import graph.
+// @ts-ignore: decorator
+@lazy
+var __toildbMigratedFlag: bool = false;
 export function __toildbResetMigrated(): void { __toildbMigratedFlag = false; }
 export function __toildbMarkMigrated(): void { __toildbMigratedFlag = true; }
 export function __toildbWasMigrated(): bool { return __toildbMigratedFlag; }
@@ -123,10 +130,12 @@ export class Documents<K, V> {
         results.push(null);
         continue;
       }
+      const ver = <i64>load<u32>(out.dataStart + off);
+      off += 4;
       const len = <i32>load<u32>(out.dataStart + off);
       off += 4;
       const v = instantiate<V>();
-      v.decodeInto(out.subarray(off, off + len));
+      v.decodeIntoVersioned(out.subarray(off, off + len), ver);
       off += len;
       results.push(v);
     }
@@ -161,6 +170,15 @@ export class Documents<K, V> {
     return v;
   }
 
+  /// Atomically replace an EXISTING record's value, version-checked: returns true
+  /// if applied, false if a concurrent write changed the record first (optimistic
+  /// concurrency - re-read and retry) or the record is absent.
+  enqueue(key: K, value: V): bool {
+    const kb = key.encode();
+    const vb = value.encode();
+    return toildbHost.enqueue(this.__handle, kb.dataStart, kb.byteLength, vb.dataStart, vb.byteLength, 0) == 0;
+  }
+
   /// Delete the record (idempotent).
   delete(key: K): void {
     const kb = key.encode();
@@ -323,10 +341,12 @@ export class Membership<K, M> {
     const count = load<u32>(blob.dataStart + off);
     off += 4;
     for (let i: u32 = 0; i < count; i++) {
+      const ver = <i64>load<u32>(blob.dataStart + off);
+      off += 4;
       const len = <i32>load<u32>(blob.dataStart + off);
       off += 4;
       const m = instantiate<M>();
-      m.decodeInto(blob.subarray(off, off + len));
+      m.decodeIntoVersioned(blob.subarray(off, off + len), ver);
       out.push(m);
       off += len;
     }
@@ -435,6 +455,20 @@ export class Events<K, V> {
     toildbHost.append(this.__handle, kb.dataStart, kb.byteLength, eb.dataStart, eb.byteLength, 0);
   }
 
+  /// Append `event` exactly once per `eventId`: a retried call with the same id is
+  /// a no-op and returns false; the first call appends and returns true. Idempotent
+  /// under at-least-once delivery / client retries (dedup on the caller-chosen id).
+  appendOnce(key: K, eventId: string, event: V): bool {
+    const kb = key.encode();
+    const idb = Uint8Array.wrap(String.UTF8.encode(eventId));
+    const eb = event.encode();
+    const status = toildbHost.appendOnce(
+      this.__handle, kb.dataStart, kb.byteLength,
+      idb.dataStart, idb.byteLength, eb.dataStart, eb.byteLength);
+    if (status < 0) unreachable();
+    return status == 1;
+  }
+
   /// 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`.
   latest(key: K, limit: i32): V[] {
@@ -447,10 +481,12 @@ export class Events<K, V> {
     const count = load<u32>(blob.dataStart + off);
     off += 4;
     for (let i: u32 = 0; i < count; i++) {
+      const ver = <i64>load<u32>(blob.dataStart + off);
+      off += 4;
       const len = <i32>load<u32>(blob.dataStart + off);
       off += 4;
       const ev = instantiate<V>();
-      ev.decodeInto(blob.subarray(off, off + len));
+      ev.decodeIntoVersioned(blob.subarray(off, off + len), ver);
       out.push(ev);
       off += len;
     }

package/std/ts-plugin.cjs

@@ -235,6 +235,15 @@ function init(modules) {
       node.members.forEach((m) => {
         if (!ts.isPropertyDeclaration(m) || !declHasDecorator(m, 'collection')) return;
         if (!m.type || !m.name || !ts.isIdentifier(m.name)) return;
+        // A `static` @collection field is ALREADY a static member of the class, so
+        // synthesizing a namespace const for it duplicates the name (TS2300). Only
+        // the legacy instance (type-carrier) form needs the synthesized static
+        // handle; the static form type-checks `Db.coll` on its own (no plugin).
+        const mods =
+          ts.getModifiers && ts.canHaveModifiers && ts.canHaveModifiers(m)
+            ? ts.getModifiers(m)
+            : m.modifiers;
+        if (mods && mods.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) return;
         consts += `  const ${m.name.text}: ${m.type.getText(sf)};\n`;
       });
       if (consts) {