toilscript 0.1.28 → 0.1.29

package/dist/web.js

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

package/std/assembly/bindings/toildb.ts

@@ -126,6 +126,67 @@ export namespace toildbHost {
     idemPtr: usize
   ): i32;
 
+  // membership.contains -> 1 present | 0 absent | negative error.
+  // @ts-ignore: decorator
+  @external("env", "data.membership_contains")
+  export declare function membershipContains(
+    handle: u32, setPtr: usize, setLen: i32, memberPtr: usize, memberLen: i32
+  ): i32;
+
+  // membership.add -> 0 ok | negative error.
+  // @ts-ignore: decorator
+  @external("env", "data.membership_add")
+  export declare function membershipAdd(
+    handle: u32, setPtr: usize, setLen: i32, memberPtr: usize, memberLen: i32, idemPtr: usize
+  ): i32;
+
+  // membership.remove -> 0 ok | negative error.
+  // @ts-ignore: decorator
+  @external("env", "data.membership_remove")
+  export declare function membershipRemove(
+    handle: u32, setPtr: usize, setLen: i32, memberPtr: usize, memberLen: i32, idemPtr: usize
+  ): i32;
+
+  // membership.list(limit) -> framed-list length (stashed) | negative error.
+  // The blob is `u32 count` then per member `u32 len + bytes`.
+  // @ts-ignore: decorator
+  @external("env", "data.membership_list")
+  export declare function membershipList(handle: u32, setPtr: usize, setLen: i32, limit: i32): i32;
+
+  // capacity.set_total(total: i64) -> 0 ok | negative error (job/derive only).
+  // @ts-ignore: decorator
+  @external("env", "data.capacity_set_total")
+  export declare function capacitySetTotal(
+    handle: u32, keyPtr: usize, keyLen: i32, total: i64, idemPtr: usize
+  ): i32;
+
+  // capacity.available -> 8 (the i64 available stashed as 8 LE bytes) | neg.
+  // @ts-ignore: decorator
+  @external("env", "data.capacity_available")
+  export declare function capacityAvailable(handle: u32, keyPtr: usize, keyLen: i32): i32;
+
+  // capacity.reserve(amount: i64, ttl_ms: i64) -> 8 (the u64 reservation id
+  // stashed) | -2 insufficient | negative error.
+  // @ts-ignore: decorator
+  @external("env", "data.capacity_reserve")
+  export declare function capacityReserve(
+    handle: u32, keyPtr: usize, keyLen: i32, amount: i64, ttlMs: i64, idemPtr: usize
+  ): i32;
+
+  // capacity.confirm(reservationId: i64) -> 1 confirmed | 0 unknown | neg.
+  // @ts-ignore: decorator
+  @external("env", "data.capacity_confirm")
+  export declare function capacityConfirm(
+    handle: u32, keyPtr: usize, keyLen: i32, reservationId: i64, idemPtr: usize
+  ): i32;
+
+  // capacity.cancel(reservationId: i64) -> 1 cancelled | 0 unknown/confirmed | neg.
+  // @ts-ignore: decorator
+  @external("env", "data.capacity_cancel")
+  export declare function capacityCancel(
+    handle: u32, keyPtr: usize, keyLen: i32, reservationId: i64, idemPtr: usize
+  ): i32;
+
   // counter.get -> 8 (the i64 sum stashed as 8 LE bytes) | negative error.
   // @ts-ignore: decorator
   @external("env", "data.counter_get")

package/std/assembly/toildb.ts

@@ -48,6 +48,7 @@ function __toildbTakeGrow(): Uint8Array {
 
 /// A mutable keyed-entity collection (spec 7.1). `V` is the `@data` value type,
 /// `K` the `@data` key type.
+@global
 export class Record<V, K> {
   private __handle: u32;
 
@@ -154,6 +155,7 @@ export class Record<V, K> {
 /// leaderboards, rendered fragments. Read by any function kind; PUBLISHED only
 /// by a `@derive`/`@job` (the host kind gate enforces it). `V` is the `@data`
 /// value type, `K` the `@data` key type.
+@global
 export class View<V, K> {
   private __handle: u32;
 
@@ -192,12 +194,14 @@ export class View<V, K> {
 /// The result of a `unique.claim` (spec 8.6). `claimed` is true when the caller
 /// owns the key (a fresh claim or an idempotent re-claim of its own); when
 /// false, `owner` is the value that currently holds the key.
+@global
 export class ClaimResult<V> {
   constructor(public claimed: bool, public owner: V | null) {}
 }
 
 /// A globally-unique claim collection (spec 7.6): username, email, slug, ...
 /// `V` is the `@data` OWNER value type, `K` the `@data` claim-key type.
+@global
 export class Unique<V, K> {
   private __handle: u32;
 
@@ -244,9 +248,125 @@ export class Unique<V, K> {
   }
 }
 
+/// An unordered set (spec 7.3): followers, tags, ACLs, room members. `M` is the
+/// `@data` member type, `K` the `@data` set-key type.
+@global
+export class Membership<M, K> {
+  private __handle: u32;
+
+  constructor(handle: u32) {
+    this.__handle = handle;
+  }
+
+  /// Whether `member` is in the set keyed by `key`.
+  contains(key: K, member: M): bool {
+    const kb = key.encode();
+    const mb = member.encode();
+    return toildbHost.membershipContains(
+      this.__handle, kb.dataStart, kb.byteLength, mb.dataStart, mb.byteLength
+    ) == 1;
+  }
+
+  /// Add `member` to the set (idempotent).
+  add(key: K, member: M): void {
+    const kb = key.encode();
+    const mb = member.encode();
+    toildbHost.membershipAdd(
+      this.__handle, kb.dataStart, kb.byteLength, mb.dataStart, mb.byteLength, 0
+    );
+  }
+
+  /// Remove `member` from the set (idempotent).
+  remove(key: K, member: M): void {
+    const kb = key.encode();
+    const mb = member.encode();
+    toildbHost.membershipRemove(
+      this.__handle, kb.dataStart, kb.byteLength, mb.dataStart, mb.byteLength, 0
+    );
+  }
+
+  /// Up to `limit` members of the set. Decodes each framed member into an `M`.
+  list(key: K, limit: i32): M[] {
+    const kb = key.encode();
+    const status = toildbHost.membershipList(this.__handle, kb.dataStart, kb.byteLength, limit);
+    if (status < 0) unreachable();
+    const blob = __toildbTake(status);
+    const out = new Array<M>();
+    let off: i32 = 0;
+    const count = load<u32>(blob.dataStart + off);
+    off += 4;
+    for (let i: u32 = 0; i < count; i++) {
+      const len = <i32>load<u32>(blob.dataStart + off);
+      off += 4;
+      const m = instantiate<M>();
+      m.decodeInto(blob.subarray(off, off + len));
+      out.push(m);
+      off += len;
+    }
+    return out;
+  }
+}
+
+/// A finite, strongly-consistent resource (spec 7.7): limited stock, seats,
+/// rate grants. Reserve/confirm/cancel two-phase holds prevent oversell. `K` is
+/// the `@data` key type (the value is the host-owned escrow ledger).
+@global
+export class Capacity<K> {
+  private __handle: u32;
+
+  constructor(handle: u32) {
+    this.__handle = handle;
+  }
+
+  /// Units available to reserve right now.
+  available(key: K): i64 {
+    const kb = key.encode();
+    const status = toildbHost.capacityAvailable(this.__handle, kb.dataStart, kb.byteLength);
+    if (status < 0) unreachable();
+    return load<i64>(__toildbTake(status).dataStart);
+  }
+
+  /// Hold `amount` for `ttlMs` (it auto-releases if not confirmed in time).
+  /// Returns the reservation id (> 0), or 0 if there was not enough available
+  /// (no oversell).
+  reserve(key: K, amount: i64, ttlMs: i64): u64 {
+    const kb = key.encode();
+    const status = toildbHost.capacityReserve(
+      this.__handle, kb.dataStart, kb.byteLength, amount, ttlMs, 0
+    );
+    if (status == -2) return 0; // insufficient
+    if (status < 0) unreachable();
+    return load<u64>(__toildbTake(status).dataStart);
+  }
+
+  /// Finalize a hold into a permanent consume. Returns whether the id was valid.
+  confirm(key: K, reservationId: u64): bool {
+    const kb = key.encode();
+    return toildbHost.capacityConfirm(
+      this.__handle, kb.dataStart, kb.byteLength, reservationId as i64, 0
+    ) == 1;
+  }
+
+  /// Release a hold back to available (a confirmed sale cannot be cancelled).
+  cancel(key: K, reservationId: u64): bool {
+    const kb = key.encode();
+    return toildbHost.capacityCancel(
+      this.__handle, kb.dataStart, kb.byteLength, reservationId as i64, 0
+    ) == 1;
+  }
+
+  /// Set the ceiling (restock / reduce). `@job`/`@derive` only; the kind gate
+  /// (compile + runtime) enforces it.
+  setTotal(key: K, total: i64): void {
+    const kb = key.encode();
+    toildbHost.capacitySetTotal(this.__handle, kb.dataStart, kb.byteLength, total, 0);
+  }
+}
+
 /// A commutative integer counter (spec 7.4): likes, view counts, inventory.
 /// `K` is the `@data` key type; the value is a host-aggregated i64 rollup (there
 /// is no `set`, only `add` and `get`, so concurrent deltas never lose writes).
+@global
 export class Counter<K> {
   private __handle: u32;
 
@@ -273,6 +393,7 @@ export class Counter<K> {
 /// An append-only event log (spec 7.5): activity feeds, audit trails, the
 /// fact stream a `@derive` consumes. `V` is the `@data` event type, `K` the
 /// `@data` stream-key type.
+@global
 export class Events<V, K> {
   private __handle: u32;
 

package/std/assembly/toilscript.d.ts

@@ -85,6 +85,102 @@ 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;
 
+// --- ToilDB (@database / @collection + the @query/@action/... function kinds),
+//     handled natively by the compiler; typed here so editors accept the bare forms ---
+
+/** Marks a class as a ToilDB database: each `@collection` field becomes a typed,
+ *  lazily-resolved collection handle (`App.users.get(...)`). */
+declare function database(target: Function): void;
+
+/** Declares a `@database` field as a collection - a `Record`/`View`/`Unique`/
+ *  `Counter`/`Events`/`Membership`/`Capacity` handle. */
+declare function collection(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
+ *  views/rollups; `@job` is background work; `@admin` is control-plane only. The
+ *  compiler enforces the family x kind matrix (a `@query` calling `.patch` is a
+ *  compile error). */
+declare function query(target: Function): void;
+declare function action(target: Function): void;
+declare function job(target: Function): void;
+declare function derive(target: Function): void;
+declare function admin(target: Function): void;
+
+// The ToilDB collection HANDLES are ambient globals (no import) - the compiler
+// provides them (`std/assembly/toildb`, `@global`); these typings let editors
+// recognize `@collection users!: Record<User, UserId>` and `App.users.get(...)`.
+// `K`/`V`/`M` are `@data` types (the binary codec the host marshals).
+
+/** A mutable keyed-entity collection (spec 7.1): user profiles, items, sessions. */
+declare class Record<V, K> {
+  get(key: K): V | null;
+  require(key: K): V;
+  exists(key: K): bool;
+  getMany(keys: K[]): (V | null)[];
+  create(key: K, value: V): bool;
+  patch(key: K, value: V): V;
+  delete(key: K): void;
+  getDelete(key: K): V | null;
+}
+
+/** A precomputed, read-optimized projection (spec 7.2): pages, leaderboards. */
+declare class View<V, K> {
+  get(key: K): V | null;
+  require(key: K): V;
+  publish(key: K, value: V): void;
+}
+
+/** The result of a `unique.claim` (spec 8.6). */
+declare class ClaimResult<V> {
+  claimed: bool;
+  owner: V | null;
+  constructor(claimed: bool, owner: V | null);
+}
+
+/** A globally-unique claim collection (spec 7.6): usernames, emails, slugs. */
+declare class Unique<V, K> {
+  lookup(key: K): V | null;
+  claim(key: K, value: V): ClaimResult<V>;
+  release(key: K, value: V): void;
+}
+
+/** An unordered set (spec 7.3): followers, tags, ACLs, room members. */
+declare class Membership<M, K> {
+  contains(key: K, member: M): bool;
+  add(key: K, member: M): void;
+  remove(key: K, member: M): void;
+  list(key: K, limit: i32): M[];
+}
+
+/** A finite, strongly-consistent resource via escrow (spec 7.7): stock, seats. */
+declare class Capacity<K> {
+  available(key: K): i64;
+  reserve(key: K, amount: i64, ttlMs: i64): u64;
+  confirm(key: K, reservationId: u64): bool;
+  cancel(key: K, reservationId: u64): bool;
+  setTotal(key: K, total: i64): void;
+}
+
+/** A commutative integer counter (spec 7.4): likes, view counts, inventory. */
+declare class Counter<K> {
+  get(key: K): i64;
+  add(key: K, delta: i64): void;
+}
+
+/** An append-only event log (spec 7.5): activity feeds, audit trails. */
+declare class Events<V, K> {
+  append(key: K, event: V): void;
+  latest(key: K, limit: i32): V[];
+}
+
+// The handles are ambient (no import needed), but `import { Counter } from
+// 'toildb'` is also accepted for editors that prefer explicit imports - it just
+// re-exports the same globals.
+declare module 'toildb' {
+  export { Record, View, Unique, ClaimResult, Membership, Capacity, Counter, Events };
+}
+
 // Big integers, native globals implemented in std/assembly/bignum. The
 // arithmetic/bitwise/comparison operators
 // (+ - * / % & | ^ << >> == != < > <= >=) are operator overloads resolved by