toolcraft 0.0.749 → 0.0.750

package/node_modules/@poe-code/safe-fs/dist/testing/object-io-metrics.js

@@ -0,0 +1,143 @@
+export class ObjectIoMetrics {
+    now;
+    phases = {};
+    current = "setup";
+    started;
+    constructor(now = () => performance.now()) {
+        this.now = now;
+        this.started = now();
+        this.phases[this.current] = { elapsedMs: 0, operations: {} };
+    }
+    phase(name) {
+        const time = this.now();
+        this.phases[this.current].elapsedMs += time - this.started;
+        this.started = time;
+        this.current = name;
+        this.phases[name] ??= { elapsedMs: 0, operations: {} };
+    }
+    async measure(category, name, operation) {
+        const operations = this.phases[this.current].operations;
+        const entry = operations[`${category}.${name}`] ??= { count: 0, failed: 0, elapsedMs: 0 };
+        entry.count++;
+        const started = this.now();
+        try {
+            return await operation();
+        }
+        catch (error) {
+            entry.failed++;
+            throw error;
+        }
+        finally {
+            entry.elapsedMs += this.now() - started;
+        }
+    }
+    snapshot() {
+        const result = structuredClone(this.phases);
+        result[this.current].elapsedMs += this.now() - this.started;
+        return result;
+    }
+}
+/** Timings are inclusive: store publication can contain staging reads and backend I/O. */
+export function measureObjectIoStore(store, metrics) {
+    const version = (head) => ({
+        revision: head.revision, stat: head.stat,
+        ...(head.publicationToken === undefined ? {} : { publicationToken: head.publicationToken }),
+        read: (...args) => metrics.measure("version", "read", () => head.read(...args)),
+        close: () => metrics.measure("version", "close", () => head.close()),
+    });
+    const publish = store.publish;
+    const createStaging = store.createStaging;
+    return {
+        async acquire(...args) {
+            const head = await metrics.measure("store", "acquire", () => store.acquire(...args));
+            return head && version(head);
+        },
+        ...(publish ? { async publish(...args) {
+                return version(await metrics.measure("store", "publish", () => publish.apply(store, args)));
+            } } : {}),
+        ...(createStaging ? { async createStaging(...args) {
+                const staging = await metrics.measure("store", "createStaging", () => createStaging.apply(store, args));
+                return {
+                    readPage: (...values) => metrics.measure("staging", "readPage", () => staging.readPage(...values)),
+                    writePage: (...values) => metrics.measure("staging", "writePage", () => staging.writePage(...values)),
+                    truncate: (...values) => metrics.measure("staging", "truncate", () => staging.truncate(...values)),
+                    close: () => metrics.measure("staging", "close", () => staging.close()),
+                };
+            } } : {}),
+    };
+}
+export function delayObjectIoBackend(backend, metrics, delayMs, sleep = duration => new Promise(resolve => setTimeout(resolve, duration))) {
+    if (!Number.isSafeInteger(delayMs) || delayMs < 0)
+        throw new RangeError("Backend delay must be a nonnegative integer");
+    return new Proxy(backend, { get(target, property) {
+            const value = Reflect.get(target, property, target);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => metrics.measure("backend", String(property), async () => {
+                if (delayMs)
+                    await sleep(delayMs);
+                return value.apply(target, args);
+            });
+        } });
+}
+export function createObjectIoReadbackStream(options) {
+    const reader = options.body.getReader({ mode: "byob" });
+    const encoder = new TextEncoder();
+    let offset = 0;
+    let cleanup;
+    const dispose = () => cleanup ??= (async () => {
+        options.metrics.phase("fixtureCleanup");
+        await options.dispose();
+        options.metrics.phase("complete");
+    })();
+    options.metrics.phase("canonicalStream");
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const chunk = await options.metrics.measure("stream", "read", () => reader.read(new Uint8Array(65536)));
+                if (chunk.done) {
+                    if (offset !== options.size)
+                        throw new Error("Canonical readback size mismatch");
+                    await dispose();
+                    controller.enqueue(encoder.encode(JSON.stringify({ ...options.summary(), type: "summary", completed: true,
+                        canonicalBytes: offset, phases: options.metrics.snapshot() }) + "\n"));
+                    controller.close();
+                    reader.releaseLock();
+                    return;
+                }
+                if (offset + chunk.value.length > options.size)
+                    throw new Error("Canonical readback size mismatch");
+                const base64 = btoa(String.fromCharCode(...chunk.value));
+                controller.enqueue(encoder.encode(JSON.stringify({ type: "chunk", offset, base64 }) + "\n"));
+                offset += chunk.value.length;
+            }
+            catch (error) {
+                let failure = error;
+                try {
+                    await reader.cancel(error);
+                }
+                catch (cancelError) {
+                    if (cancelError !== error)
+                        failure = new AggregateError([error, cancelError], "Readback and cancellation failed");
+                }
+                try {
+                    await dispose();
+                }
+                catch (cleanupError) {
+                    failure = new AggregateError([failure, cleanupError], "Readback and cleanup failed");
+                }
+                reader.releaseLock();
+                controller.error(failure);
+            }
+        },
+        async cancel(reason) {
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                await dispose();
+                reader.releaseLock();
+            }
+        },
+    });
+}

package/node_modules/@poe-code/safe-fs/dist/testing/object-publication.d.ts

@@ -0,0 +1,19 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import type { ObjectFileDescriptorOptions, ObjectFilePublicationStore } from "../fs/object-publication/index.js";
+export interface ObjectFilePublicationConformanceFixture {
+    readonly fs: FileSystem;
+    readonly store: ObjectFilePublicationStore;
+    readonly root: string;
+    readonly descriptorOptions?: ObjectFileDescriptorOptions;
+    dispose(): void | Promise<void>;
+}
+export interface ObjectFilePublicationConformanceOptions {
+    readonly createFixture: () => ObjectFilePublicationConformanceFixture | Promise<ObjectFilePublicationConformanceFixture>;
+    readonly requireStaging?: boolean;
+    readonly descriptorOptions?: ObjectFileDescriptorOptions;
+}
+export interface ObjectFilePublicationConformanceCase {
+    readonly name: string;
+    run(): Promise<void>;
+}
+export declare function createObjectFilePublicationConformanceCases(options: ObjectFilePublicationConformanceOptions): ObjectFilePublicationConformanceCase[];

package/node_modules/@poe-code/safe-fs/dist/testing/object-publication.js

@@ -0,0 +1,209 @@
+import { finishCleanup } from "../contracts/cleanup.js";
+import { toByteSource } from "../contracts/io.js";
+import { validatePath } from "../contracts/virtual-path.js";
+import { withObjectFileDescriptors } from "../fs/object-publication/index.js";
+function check(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function bytes(actual, expected) {
+    check(actual instanceof Uint8Array && actual.length === expected.length
+        && actual.every((value, index) => value === expected[index]), "object publication returned incorrect bytes");
+}
+function conflict(reason) {
+    check(typeof reason === "object" && reason !== null && "code" in reason
+        && (reason.code === "EAGAIN" || reason.code === "EEXIST"), "conditional publication must report a version/create conflict");
+}
+export function createObjectFilePublicationConformanceCases(options) {
+    const cases = [
+        {
+            name: "object publication: immutable reads survive replacement",
+            async run({ fixture, path, track, publish }) {
+                const name = path("pinned");
+                const initial = await publish(name, null, new Uint8Array([1, 2, 3, 4]));
+                const acquired = await fixture.store.acquire(name, { access: "read" });
+                check(acquired, "published file could not be acquired");
+                track(acquired);
+                check(acquired.revision === initial.revision, "acquisition did not observe the published namespace revision");
+                const replacement = await publish(name, initial.revision, new Uint8Array([5, 6, 7]));
+                check(replacement.revision !== initial.revision, "namespace revisions must change on publication");
+                bytes(await acquired.read(1, 2), new Uint8Array([2, 3]));
+                const mutable = await acquired.read(0, 4);
+                mutable.fill(0);
+                bytes(await acquired.read(0, 4), new Uint8Array([1, 2, 3, 4]));
+                bytes(await fixture.fs.readFile(name), new Uint8Array([5, 6, 7]));
+            },
+        },
+        {
+            name: "object publication: exclusive create has exactly one winner",
+            async run({ fixture, path, publish }) {
+                const name = path("exclusive");
+                const results = await Promise.allSettled([
+                    publish(name, null, new Uint8Array([1])), publish(name, null, new Uint8Array([2])),
+                ]);
+                const winners = results.filter(result => result.status === "fulfilled");
+                const failures = results.filter(result => result.status === "rejected");
+                check(winners.length === 1 && failures.length === 1, "atomic creation must admit exactly one concurrent writer");
+                conflict(failures[0].reason);
+                bytes(await fixture.fs.readFile(name), new Uint8Array([results[0].status === "fulfilled" ? 1 : 2]));
+            },
+        },
+        {
+            name: "object publication: stale updates cannot replace an acknowledged generation",
+            async run({ fixture, path, publish }) {
+                const name = path("conditional");
+                const initial = await publish(name, null, new Uint8Array([0]));
+                const results = await Promise.allSettled([
+                    publish(name, initial.revision, new Uint8Array([1])),
+                    publish(name, initial.revision, new Uint8Array([2])),
+                ]);
+                const failures = results.filter(result => result.status === "rejected");
+                check(results.filter(result => result.status === "fulfilled").length === 1 && failures.length === 1, "conditional publication admitted conflicting revisions");
+                conflict(failures[0].reason);
+                bytes(await fixture.fs.readFile(name), new Uint8Array([results[0].status === "fulfilled" ? 1 : 2]));
+            },
+        },
+        {
+            name: "object publication: cancelled creation does not publish",
+            async run({ fixture, path, track }) {
+                const name = path("cancelled");
+                const controller = new AbortController();
+                const reason = new Error("conformance cancellation");
+                controller.abort(reason);
+                let rejected = false;
+                try {
+                    track(await fixture.store.publish(name, null, toByteSource(new Uint8Array([1])), {
+                        signal: controller.signal, size: 1, mode: 0o600,
+                    }));
+                }
+                catch (error) {
+                    check(error === reason, "publication must preserve cancellation identity");
+                    rejected = true;
+                }
+                check(rejected, "cancelled publication succeeded");
+                const visible = await fixture.store.acquire(name, { access: "read" });
+                if (visible)
+                    track(visible);
+                check(visible === undefined, "cancelled creation left a published key");
+            },
+        },
+        {
+            name: "object publication: descriptor updates flush conditionally",
+            async run({ fixture, path, track, publish }) {
+                const name = path("descriptor");
+                await publish(name, null, new Uint8Array([1, 2, 3, 4]));
+                const fs = withObjectFileDescriptors(fixture.fs, fixture.store, { chunkBytes: 4, maxStagedBytes: 16, maxFileBytes: 16, ...options.descriptorOptions, ...fixture.descriptorOptions });
+                const descriptor = track(await fs.open(name, { access: "readwrite" }));
+                check(descriptor.capabilities.publication === "conditional", "descriptor publication profile was lost");
+                await descriptor.write(new Uint8Array([7]), 1);
+                bytes(await fixture.fs.readFile(name), new Uint8Array([1, 2, 3, 4]));
+                await descriptor.sync(false);
+                bytes(await fixture.fs.readFile(name), new Uint8Array([1, 7, 3, 4]));
+                await descriptor.truncate(2);
+                await descriptor.truncate(4);
+                await descriptor.sync(false);
+                bytes(await fixture.fs.readFile(name), new Uint8Array([1, 7, 0, 0]));
+            },
+        },
+    ];
+    if (options.requireStaging)
+        cases.push({
+            name: "object staging: private pages have owned reads and truncation semantics",
+            async run({ fixture, path, track }) {
+                const name = path("staged");
+                const staging = track(await fixture.store.createStaging(name, { chunkBytes: 4, maxFileBytes: 16 }));
+                const sibling = track(await fixture.store.createStaging(name, { chunkBytes: 4, maxFileBytes: 16 }));
+                check(await staging.readPage(0) === undefined, "new staging contains an unowned page");
+                const input = new Uint8Array([1, 2, 3, 4]);
+                await staging.writePage(0, input);
+                input.fill(0);
+                const retained = await staging.readPage(0);
+                check(retained !== undefined, "staging lost an acknowledged page");
+                bytes(retained, new Uint8Array([1, 2, 3, 4]));
+                retained.fill(0);
+                bytes((await staging.readPage(0)), new Uint8Array([1, 2, 3, 4]));
+                check(await sibling.readPage(0) === undefined, "staging leaked across descriptors");
+                await staging.writePage(2, new Uint8Array([5, 6, 7, 8]));
+                await staging.truncate(2);
+                bytes((await staging.readPage(0)), new Uint8Array([1, 2, 0, 0]));
+                check(await staging.readPage(2) === undefined, "truncate retained a removed page");
+                const visible = await fixture.store.acquire(name, { access: "read" });
+                if (visible)
+                    track(visible);
+                check(visible === undefined, "private staging published a namespace entry");
+            },
+        }, {
+            name: "object staging: cancelled writes preserve acknowledged pages",
+            async run({ fixture, path, track }) {
+                const staging = track(await fixture.store.createStaging(path("stage-cancelled"), { chunkBytes: 4, maxFileBytes: 16 }));
+                await staging.writePage(0, new Uint8Array([1, 2, 3, 4]));
+                const controller = new AbortController();
+                const reason = new Error("staging cancellation");
+                controller.abort(reason);
+                let rejected = false;
+                try {
+                    await staging.writePage(0, new Uint8Array(4), { signal: controller.signal });
+                }
+                catch (error) {
+                    check(error === reason, "staging must preserve cancellation identity");
+                    rejected = true;
+                }
+                check(rejected, "cancelled staging write succeeded");
+                bytes((await staging.readPage(0)), new Uint8Array([1, 2, 3, 4]));
+            },
+        }, {
+            name: "object staging: writes larger than memory stay private until conditional sync",
+            async run({ fixture, path, track, publish }) {
+                const name = path("stage-descriptor");
+                await publish(name, null, new Uint8Array([1, 2, 3, 4]));
+                const fs = withObjectFileDescriptors(fixture.fs, fixture.store, { chunkBytes: 4, maxStagedBytes: 4, maxStagedPages: 1, maxFileBytes: 16, ...options.descriptorOptions, ...fixture.descriptorOptions });
+                const descriptor = track(await fs.open(name, { access: "readwrite" }));
+                const content = new Uint8Array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+                await descriptor.write(content, 0);
+                bytes(await fixture.fs.readFile(name), new Uint8Array([1, 2, 3, 4]));
+                const buffer = new Uint8Array(content.length);
+                check(await descriptor.read(buffer, 0) === buffer.length, "staging read was incomplete");
+                bytes(buffer, content);
+                await descriptor.sync(false);
+                bytes(await fixture.fs.readFile(name), content);
+            },
+        });
+    return cases.map(entry => ({
+        name: entry.name,
+        async run() {
+            const fixture = await options.createFixture();
+            const resources = [];
+            let failed = false;
+            try {
+                validatePath(fixture.root);
+                check(fixture.root.startsWith("/"), "conformance fixture root must be absolute");
+                check(typeof fixture.store.publish === "function", "conformance requires authoritative conditional publication");
+                if (options.requireStaging)
+                    check(typeof fixture.store.createStaging === "function", "conformance requires private object staging");
+                const root = fixture.root.endsWith("/") ? fixture.root.slice(0, -1) : fixture.root;
+                const track = (value) => {
+                    resources.push(value);
+                    return value;
+                };
+                await entry.run({ fixture, path: name => `${root}/${name}`, track,
+                    async publish(path, revision, data) {
+                        return track(await fixture.store.publish(path, revision, toByteSource(data), { size: data.length, mode: 0o600 }));
+                    },
+                });
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                await finishCleanup(async () => {
+                    const closed = await Promise.allSettled(resources.map(resource => resource.close()));
+                    const rejected = closed.find(result => result.status === "rejected");
+                    await finishCleanup(() => fixture.dispose(), rejected !== undefined);
+                    if (rejected?.status === "rejected")
+                        throw rejected.reason;
+                }, failed);
+            }
+        },
+    }));
+}

package/node_modules/@poe-code/safe-fs/dist/xml.d.ts

@@ -0,0 +1 @@
+export * from "@poe-code/xml-ast";

package/node_modules/@poe-code/safe-fs/dist/xml.js

@@ -0,0 +1 @@
+export * from "@poe-code/xml-ast";

package/node_modules/@poe-code/safe-fs/package.json

@@ -0,0 +1,189 @@
+{
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "imports": {
+    "#safe-fs-native-seek": {
+      "types": "./src/native/loader.d.ts",
+      "workerd": "./src/node/native-seek-unavailable.ts",
+      "browser": null,
+      "worker": null,
+      "default": "./dist/native/fs-seek/loader.mjs"
+    },
+    "#safe-fs-platform": {
+      "types": {
+        "workerd": "./src/platform/browser.ts",
+        "browser": "./src/platform/browser.ts",
+        "worker": "./src/platform/browser.ts",
+        "default": "./src/platform/node.ts"
+      },
+      "workerd": "./dist/platform/browser.js",
+      "browser": "./dist/platform/browser.js",
+      "worker": "./dist/platform/browser.js",
+      "default": "./dist/platform/node.js"
+    },
+    "#safe-fs-platform-path": {
+      "types": {
+        "workerd": "./src/platform/browser-path.ts",
+        "browser": "./src/platform/browser-path.ts",
+        "worker": "./src/platform/browser-path.ts",
+        "default": "./src/platform/node-path.ts"
+      },
+      "workerd": "./dist/platform/browser-path.js",
+      "browser": "./dist/platform/browser-path.js",
+      "worker": "./dist/platform/browser-path.js",
+      "default": "./dist/platform/node-path.js"
+    },
+    "#safe-fs-s3-request": {
+      "types": {
+        "workerd": "./src/fs/s3/http/request-fetch.ts",
+        "browser": "./src/fs/s3/http/request-fetch.ts",
+        "worker": "./src/fs/s3/http/request-fetch.ts",
+        "default": "./src/fs/s3/http/request-node.ts"
+      },
+      "workerd": "./dist/fs/s3/http/request-fetch.js",
+      "browser": "./dist/fs/s3/http/request-fetch.js",
+      "worker": "./dist/fs/s3/http/request-fetch.js",
+      "default": "./dist/fs/s3/http/request-node.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "workerd": "./dist/core.d.ts",
+        "browser": "./dist/core.d.ts",
+        "worker": "./dist/core.d.ts",
+        "default": "./dist/index.d.ts"
+      },
+      "workerd": "./dist/core.js",
+      "browser": "./dist/core.js",
+      "worker": "./dist/core.js",
+      "import": "./dist/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts/index.d.ts",
+      "workerd": "./dist/contracts/index.js",
+      "browser": "./dist/contracts/index.js",
+      "worker": "./dist/contracts/index.js",
+      "import": "./dist/contracts/index.js"
+    },
+    "./xml": {
+      "types": "./dist/xml.d.ts",
+      "import": "./dist/xml.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./testing/atomic": {
+      "types": "./dist/testing/atomic-filesystem.d.ts",
+      "workerd": "./dist/testing/atomic-filesystem.js",
+      "browser": "./dist/testing/atomic-filesystem.js",
+      "worker": "./dist/testing/atomic-filesystem.js",
+      "import": "./dist/testing/atomic-filesystem.js"
+    },
+    "./testing/object-publication": {
+      "types": "./dist/testing/object-publication.d.ts",
+      "workerd": "./dist/testing/object-publication.js",
+      "browser": "./dist/testing/object-publication.js",
+      "worker": "./dist/testing/object-publication.js",
+      "import": "./dist/testing/object-publication.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "workerd": null,
+      "browser": null,
+      "import": "./dist/node/index.js"
+    },
+    "./node/filesystem": {
+      "types": {
+        "workerd": "./dist/node-unavailable.d.ts",
+        "browser": "./dist/node-unavailable.d.ts",
+        "worker": "./dist/node-unavailable.d.ts",
+        "default": "./dist/node/filesystem.d.ts"
+      },
+      "workerd": null,
+      "browser": null,
+      "worker": null,
+      "import": "./dist/node/filesystem.js"
+    },
+    "./fs/memory": {
+      "types": "./dist/fs/memory/index.d.ts",
+      "import": "./dist/fs/memory/index.js"
+    },
+    "./fs/real": {
+      "types": "./dist/fs/real/index.d.ts",
+      "workerd": null,
+      "browser": null,
+      "import": "./dist/fs/real/index.js"
+    },
+    "./fs/s3/http": {
+      "types": "./dist/fs/s3/http/index.d.ts",
+      "import": "./dist/fs/s3/http/index.js"
+    },
+    "./fs/s3": {
+      "types": "./dist/fs/s3/index.d.ts",
+      "import": "./dist/fs/s3/index.js"
+    },
+    "./fs/webdav": {
+      "types": "./dist/fs/webdav/index.d.ts",
+      "import": "./dist/fs/webdav/index.js"
+    },
+    "./fs/readonly": {
+      "types": "./dist/fs/readonly/index.d.ts",
+      "import": "./dist/fs/readonly/index.js"
+    },
+    "./fs/mount": {
+      "types": "./dist/fs/mount/index.d.ts",
+      "import": "./dist/fs/mount/index.js"
+    },
+    "./fs/overlay": {
+      "types": "./dist/fs/overlay/index.d.ts",
+      "import": "./dist/fs/overlay/index.js"
+    },
+    "./fs/quota": {
+      "types": "./dist/fs/quota/index.d.ts",
+      "import": "./dist/fs/quota/index.js"
+    },
+    "./contracts/object": {
+      "types": "./dist/contracts/object.d.ts",
+      "import": "./dist/contracts/object.js"
+    },
+    "./contracts/errors": {
+      "types": "./dist/contracts/errors.d.ts",
+      "import": "./dist/contracts/errors.js"
+    },
+    "./runtime-core": {
+      "types": "./dist/runtime-core.d.ts",
+      "import": "./dist/runtime-core.js"
+    },
+    "./bridge": {
+      "types": "./dist/bridge/index.d.ts",
+      "import": "./dist/bridge/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "PROVENANCE.json",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "node-api-headers": "1.9.0"
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc -p tsconfig.json && node scripts/native-assets.mjs",
+    "build:portable": "node ../../scripts/guard-package-dist.mjs && tsc -p tsconfig.json && node scripts/native-assets.mjs --portable",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck:tests": "tsc -p tsconfig.tests.json --noEmit",
+    "test:staging-native": "node --import tsx --test tests/integration/real-staging-hardlinks.test.mjs",
+    "test:unit": "cd ../.. && vitest run packages/safe-fs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/safe-fs"
+  },
+  "license": "MIT"
+}

package/node_modules/@poe-code/task-list/README.md

@@ -14,6 +14,8 @@ Multi-list task manager with pluggable storage backends.
 
 The task lifecycle is `draft -> planned -> in-progress -> done -> archived`. `archived` is terminal.
 
+In Workers or browsers, pass a `@poe-code/safe-fs` filesystem through `fs` for Markdown and YAML stores. It must support exclusive writes, rename, unlink, and rmdir for atomic updates and locks. Node uses its host filesystem by default. GitHub stores work with an explicit `auth.token`; automatic `gh` authentication requires a host runner.
+
 ## Public API
 
 - `openTaskList(options)`: opens a task store and returns a `TaskList`

package/node_modules/@poe-code/task-list/dist/backends/gh-issues-client.d.ts

@@ -1,4 +1,4 @@
-import { type Runner } from "@poe-code/process-runner";
+import type { Runner } from "@poe-code/process-runner";
 export interface GhClientOptions {
     token: string;
     endpoint?: string;

package/node_modules/@poe-code/task-list/dist/backends/gh-issues-client.js

@@ -1,5 +1,4 @@
-import { text } from "node:stream/consumers";
-import { createHostRunner } from "@poe-code/process-runner";
+import { createDefaultRunner } from "#task-list-host";
 import { UserError } from "@poe-code/user-error";
 const DEFAULT_ENDPOINT = "https://api.github.com/graphql";
 const USER_AGENT = "poe-code-task-list/0.0.1";
@@ -41,7 +40,7 @@ export async function resolveAuth(options) {
     if (options.explicitToken !== undefined) {
         return options.explicitToken;
     }
-    const runner = options.runner ?? createHostRunner();
+    const runner = options.runner ?? createDefaultRunner();
     const handle = runner.exec({
         command: "gh",
         args: ["auth", "token"],
@@ -60,10 +59,18 @@ export async function resolveAuth(options) {
     return token;
 }
 export function resolveEndpoint(options = {}) {
-    const env = options.env ?? process.env;
+    const env = options.env ?? globalThis.process?.env ?? {};
     const host = env.GH_HOST;
     if (host !== undefined && host !== "" && host !== "github.com") {
         return `https://${host}/api/graphql`;
     }
     return DEFAULT_ENDPOINT;
 }
+async function text(stream) {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const chunk of stream) {
+        result += typeof chunk === "string" ? decoder.decode() + chunk : decoder.decode(chunk, { stream: true });
+    }
+    return result + decoder.decode();
+}

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.js

@@ -1,4 +1,4 @@
-import path from "node:path";
+import { path } from "../paths.js";
 import { parseDocument, stringify } from "yaml";
 import { TASK_SCHEMA_ID } from "../schema/ids.js";
 import { eventsFromState, findEvent } from "../state-machine.js";
@@ -503,7 +503,7 @@ function createTasksView(deps, layout, list) {
             const desiredFilename = activeTaskFilename(entry.id, desiredOrder, width);
             if (entry.filename !== desiredFilename) {
                 const fromPath = path.join(listDirectoryPath, entry.filename);
-                const stagingPath = path.join(listDirectoryPath, `${desiredFilename}.staging-${process.pid}-${index}`);
+                const stagingPath = path.join(listDirectoryPath, `${desiredFilename}.staging-${crypto.randomUUID()}-${index}`);
                 const targetPath = path.join(listDirectoryPath, desiredFilename);
                 try {
                     await deps.fs.rename(fromPath, stagingPath);