knitting 0.1.56 → 0.1.60

package/src/worker/task-loader.d.ts

@@ -9,10 +9,11 @@ type GetFunctionParams = {
     permission?: ResolvedPermissionProtocol;
 };
 type WorkerCallable = (args: unknown, abortToolkit?: unknown) => unknown;
-export declare const enum TimeoutKind {
-    Reject = 0,
-    Resolve = 1
-}
+export declare const TimeoutKind: {
+    readonly Reject: 0;
+    readonly Resolve: 1;
+};
+export type TimeoutKind = typeof TimeoutKind[keyof typeof TimeoutKind];
 export type TimeoutSpec = {
     ms: number;
     kind: TimeoutKind;

package/src/worker/task-loader.js

@@ -1,27 +1,33 @@
 import { endpointSymbol } from "../common/task-symbol.js";
-import { toModuleUrl } from "../common/module-url.js";
+import { toImportSpecifier, toModuleUrl } from "../common/module-url.js";
+// const object, not `const enum`: Andromeda's Nova engine can't parse `enum`.
+// No longer inlined, but only read on cold paths.
+export const TimeoutKind = {
+    Reject: 0,
+    Resolve: 1,
+};
 const normalizeTimeout = (timeout) => {
     if (timeout == null)
         return undefined;
     if (typeof timeout === "number") {
         const ms = Math.floor(timeout);
         return ms >= 0
-            ? { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") }
+            ? { ms, kind: TimeoutKind.Reject, value: new Error("Task timeout") }
             : undefined;
     }
     const ms = Math.floor(timeout.time);
     if (!(ms >= 0))
         return undefined;
     if ("default" in timeout) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: timeout.default };
+        return { ms, kind: TimeoutKind.Resolve, value: timeout.default };
     }
     if (timeout.maybe === true) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: undefined };
+        return { ms, kind: TimeoutKind.Resolve, value: undefined };
     }
     if ("error" in timeout) {
-        return { ms, kind: 0 /* TimeoutKind.Reject */, value: timeout.error };
+        return { ms, kind: TimeoutKind.Reject, value: timeout.error };
     }
-    return { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") };
+    return { ms, kind: TimeoutKind.Reject, value: new Error("Task timeout") };
 };
 const composeWorkerCallable = (fixed, _permission) => {
     return fixed.f;
@@ -30,7 +36,7 @@ export const getFunctions = async ({ list, ids, names, at, permission }) => {
     const modules = list.map((specifier) => toModuleUrl(specifier));
     const nameSet = new Set(names);
     const results = await Promise.all(modules.map(async (imports) => {
-        const module = (await import(imports));
+        const module = (await import(toImportSpecifier(imports)));
         const fixedTasks = Object.entries(module)
             .filter(([_, value]) => value != null && typeof value === "object" &&
             //@ts-ignore Reason -> trust me

package/src/worker/timers.js

@@ -1,7 +1,7 @@
-var Comment;
-(function (Comment) {
-    Comment[Comment["thisIsAHint"] = 0] = "thisIsAHint";
-})(Comment || (Comment = {}));
+// const object, not `enum`: Andromeda's Nova engine can't parse `enum`.
+const Comment = {
+    thisIsAHint: 0,
+};
 const maybeGc = (() => {
     const host = globalThis;
     const gc = typeof host.gc === "function"
@@ -51,6 +51,7 @@ const isPlainNodeWindows = runtimeGlobals.process?.platform === "win32" &&
 // runners appear to hang. The native wait already polls internally, so this is
 // just bounding each poll slice.
 const nativeWaitTimeoutMs = (parkMs) => isPlainNodeWindows ? 1 : Number.isFinite(parkMs) ? parkMs : Infinity;
+const pollingWaitTimeoutMs = (parkMs) => Number.isFinite(parkMs) ? Math.min(Math.max(parkMs, 0), 1) : 1;
 export const whilePausing = ({ pauseInNanoseconds }) => {
     const forNanoseconds = pauseInNanoseconds ?? DEFAULT_PAUSE_TIME;
     if (!a_pause || forNanoseconds <= 0)
@@ -108,8 +109,9 @@ export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, tx
         }
         else if (a_wait && waitFallbackView) {
             // waitFallbackView is never notified — this wait only ever times out and
-            // re-polls, so it must stay finite or the worker would hang forever.
-            a_wait(waitFallbackView, 0, 0, Number.isFinite(parkMs) ? parkMs : Infinity);
+            // re-polls. Keep the slice short and finite so FFI-backed process workers
+            // stay responsive without a cross-process native wake primitive.
+            a_wait(waitFallbackView, 0, 0, pollingWaitTimeoutMs(parkMs));
         }
         a_store(rxStatus, 0, 1);
     };