@hew-lang/sandbox-vm 0.6.1 → 0.6.2

package/dist/interpreter/unicode.d.ts

@@ -0,0 +1,3 @@
+/** The native Unicode operations, independent of the JavaScript host's version. */
+export declare function charProperty(value: string, bit: number): boolean;
+export declare function charCase(value: string, kind: "upper" | "lower" | "title"): string;

package/dist/interpreter/unicode.js

@@ -0,0 +1,35 @@
+import { CATEGORY_RANGES, UPPER_MAPPING, LOWER_MAPPING, TITLE_MAPPING, } from "./unicode-data.js";
+/** The native Unicode operations, independent of the JavaScript host's version. */
+export function charProperty(value, bit) {
+    const scalar = value.codePointAt(0);
+    let low = 0, high = CATEGORY_RANGES.length / 3;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (CATEGORY_RANGES[middle * 3 + 1] < scalar)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return (low * 3 < CATEGORY_RANGES.length &&
+        CATEGORY_RANGES[low * 3] <= scalar &&
+        (CATEGORY_RANGES[low * 3 + 2] & (1 << bit)) !== 0);
+}
+export function charCase(value, kind) {
+    const table = kind === "upper"
+        ? UPPER_MAPPING
+        : kind === "lower"
+            ? LOWER_MAPPING
+            : TITLE_MAPPING;
+    const scalar = value.codePointAt(0);
+    let low = 0, high = table.length / 2;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (table[middle * 2] < scalar)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return table[low * 2] === scalar
+        ? String.fromCodePoint(table[low * 2 + 1])
+        : value;
+}

package/dist/interpreter/v1/actor-identity.d.ts

@@ -0,0 +1,3 @@
+import type { VmValue } from "../values.js";
+/** Role handles retain their own identity independently of their occupant. */
+export declare function actorIdentical(left: VmValue | undefined, right: VmValue | undefined): boolean;

package/dist/interpreter/v1/actor-identity.js

@@ -0,0 +1,7 @@
+/** Role handles retain their own identity independently of their occupant. */
+export function actorIdentical(left, right) {
+    if ((left?.kind !== "actor" && left?.kind !== "supervisor") ||
+        (right?.kind !== "actor" && right?.kind !== "supervisor"))
+        throw new Error("actor identity requires actor or supervisor handles");
+    return left.kind === right.kind && left.id === right.id;
+}

package/dist/interpreter/v1/actor-waits.d.ts

@@ -0,0 +1,6 @@
+/** Pending strict actor turns. Keys identify incarnations, never role handles. */
+export declare class ActorWaits<T> {
+    private readonly edges;
+    ready(owner: T): void;
+    pending(owner: T, targets: readonly T[]): T[] | null;
+}

package/dist/interpreter/v1/actor-waits.js

@@ -0,0 +1,33 @@
+/** Pending strict actor turns. Keys identify incarnations, never role handles. */
+export class ActorWaits {
+    edges = new Map();
+    ready(owner) {
+        this.edges.delete(owner);
+    }
+    pending(owner, targets) {
+        this.edges.set(owner, targets);
+        const blocked = new Set([...this.edges]
+            .filter(([, targets]) => targets.length > 0)
+            .map(([owner]) => owner));
+        for (;;) {
+            const escaped = [...blocked].filter((actor) => this.edges.get(actor).some((target) => !blocked.has(target)));
+            if (escaped.length === 0)
+                break;
+            for (const actor of escaped)
+                blocked.delete(actor);
+        }
+        if (!blocked.has(owner))
+            return null;
+        const path = [];
+        const seen = new Set();
+        let next = owner;
+        while (!seen.has(next)) {
+            seen.add(next);
+            path.push(next);
+            next = this.edges.get(next)[0];
+        }
+        path.push(next);
+        this.ready(owner);
+        return path;
+    }
+}

package/dist/interpreter/v1/codecs.js

@@ -1,4 +1,4 @@
-import { UNIT } from "../values.js";
+import { UNIT, stringValue } from "../values.js";
 import { runtimeTag } from "./package.js";
 import { collectionOperation } from "./value-operations.js";
 class DecodeFailure extends Error {
@@ -102,7 +102,7 @@ function* fromBridge(pkg, shape, id, value, context) {
     if (node === "Bool")
         return { kind: "bool", value: Boolean(value) };
     if (node === "Char" || node === "String")
-        return { kind: "string", value: String(value) };
+        return stringValue(String(value));
     if (node === "Bytes")
         return {
             kind: "vector",
@@ -216,13 +216,10 @@ export function* executeCodec(pkg, term, input, bridge, propertyInput) {
                 elementType: "u8",
                 items: bytes.map((byte) => ({ kind: "i64", value: BigInt(byte) })),
             }
-            : {
-                kind: "string",
-                value: new TextDecoder("utf-8", {
-                    fatal: true,
-                    ignoreBOM: true,
-                }).decode(new Uint8Array(bytes)),
-            };
+            : stringValue(new TextDecoder("utf-8", {
+                fatal: true,
+                ignoreBOM: true,
+            }).decode(new Uint8Array(bytes)));
     }
     const root = result.ok ? shape.root : term.decoded.error_root;
     const context = {