@andreiltd/componentize-qjs-binding-win32-arm64-msvc 0.4.3 → 0.4.5

package/README.md

@@ -197,6 +197,7 @@ a project root that contains shared files or `node_modules`.
 |----------|---------|---------|
 | `list<T>` | `Array` | `[1, 2, 3]` |
 | `list<u8>` | `Uint8Array` or `Array` | `new Uint8Array([1, 2, 3])` |
+| `map<K, V>` | `Map` | `new Map([["key", value]])` |
 | `tuple<T, U, ...>` | `Array` | `[42, "hello"]` |
 | `option<T>` | `T \| null` (nested: `{ tag: "some"\|"none", val }`) | `null` for none; `option<option<T>>` is wrapped |
 | `result<T, E>` | top-level function result: return `T` or throw `E`; nested result: `{ tag: "ok"\|"err", val?: T\|E }` | `return 42` / `throw "error"` |
@@ -226,6 +227,15 @@ output.blockingWriteAndFlush(chunk);
 `[static]` methods are exposed on the resource class and `[constructor]` makes
 the class callable with `new`.
 
+Owned imported resources support `[Symbol.dispose]()` for deterministic
+cleanup. Passing one to a WIT `own<T>` parameter transfers ownership and
+invalidates the original wrapper. Borrowed wrappers expire when their component
+call completes and cannot be transferred or disposed as owners. Resources lent
+to an in-flight import remain alive and cannot be disposed or transferred until
+that import completes. Ownership is restored for unconsumed stream/future writes
+and for imported calls cancelled before they start. Await imports using an
+incoming borrowed resource before returning from its export.
+
 ### Async Exports
 
 Async exports are declared with the `async` keyword in WIT and implemented
@@ -247,6 +257,36 @@ export async function greet(name) {
 }
 ```
 
+Exported resource methods and static methods may also be async. Implement them
+as `async` members on the exported JavaScript class; resource constructors
+remain synchronous:
+
+```wit
+package example:counter;
+
+interface counter-api {
+    resource counter {
+        constructor(initial: u32);
+        add: async func(value: u32) -> u32;
+        create: static async func(initial: u32) -> counter;
+    }
+}
+
+world counter {
+    export counter-api;
+}
+```
+
+```js
+class Counter {
+    constructor(initial) { this.value = initial; }
+    async add(value) { this.value += value; return this.value; }
+    static async create(initial) { return new this(initial); }
+}
+
+export const counterApi = { Counter };
+```
+
 ### Streams
 
 Streams transfer a sequence of values between components. Lifted WIT streams
@@ -374,7 +414,7 @@ world async-value {
 ```
 
 ```js
-async function compute() {
+export async function compute() {
     const { readable, writable } = wit.Future();
 
     // Write the value (fire-and-forget; completes when reader reads)
@@ -387,6 +427,16 @@ async function compute() {
 **Future type constants** follow the same pattern: `wit.Future.U32`,
 `wit.Future.STRING`, etc.
 
+Future handles are deliberately not thenable: use `await readable.read()` to
+obtain the payload. This keeps `return readable` in an async export from
+implicitly consuming the future, and preserves nested future handles.
+Repeated `read()` calls share the same Promise; a cancelled read rejects that
+Promise and allows a subsequent read to retry.
+
+`wit.Future.from(value, type)` adapts a value or Promise and returns
+`{ readable, completion }`. Return its `readable` from an async export rather
+than returning the payload Promise directly, which JavaScript would await.
+
 **FutureReadable methods:**
 
 | Method | Returns | Description |
@@ -405,17 +455,25 @@ async function compute() {
 
 ### Resource Cleanup
 
-Stream and future handles support
+Owned imported resources, stream endpoints, and future endpoints support
 [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management)
 via `Symbol.dispose`. In environments that support `using`:
 
 ```js
 {
-    using stream = wit.Stream();
-    // stream.writable and stream.readable are auto-dropped when leaving scope
+    const stream = wit.Stream();
+    using writable = stream.writable;
+    using readable = stream.readable;
+    // Each endpoint is disposed when leaving scope.
 }
 ```
 
+The factory's `{ readable, writable }` pair is not itself disposable.
+Complete an endpoint's pending operation (or cancel it and await its
+settlement) before leaving its `using` scope or calling `.drop()`.
+Host-requested task cancellation retains pending ABI buffers until the host
+acknowledges each operation's completion or cancellation.
+
 Otherwise, call `.drop()` explicitly to release handles.
 
 ## Node.js API

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andreiltd/componentize-qjs-binding-win32-arm64-msvc",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "cpu": [
     "arm64"
   ],