@fungi.computer/computer 0.0.0-stage → 0.0.1

package/dist/files.js

@@ -0,0 +1,136 @@
+import { replaceOutputSchema, } from "./operation-contract.js";
+const utf8 = new TextEncoder();
+function entryType(entry) {
+    if (entry.isSymbolicLink)
+        return "symlink";
+    if (entry.isFile)
+        return "file";
+    if (entry.isDirectory)
+        return "directory";
+    return "symlink";
+}
+function childPath(parent, name) {
+    return parent === "/" ? `/${name}` : `${parent}/${name}`;
+}
+function decodeUtf8(bytes, path) {
+    return decodeUtf8Page(bytes, path, false).content;
+}
+/** Decode a bounded byte page without consuming an incomplete final UTF-8 character. */
+export function decodeUtf8Page(bytes, path, moreBytesRemain) {
+    try {
+        const content = new TextDecoder("utf-8", {
+            fatal: true,
+            ignoreBOM: true,
+        }).decode(bytes, { stream: moreBytesRemain });
+        const byteLength = utf8.encode(content).byteLength;
+        if (byteLength === 0 && bytes.byteLength > 0) {
+            throw new Error(`Files read cannot advance a UTF-8 page: ${path}`);
+        }
+        return { content, byteLength };
+    }
+    catch (cause) {
+        throw new Error(`Files path is not valid UTF-8: ${path}`, { cause });
+    }
+}
+async function readBytes(workspace, path, byteOffset, byteLength) {
+    const options = {
+        byteOffset,
+        byteLength,
+    };
+    const source = await workspace.fs.readFile(path, options);
+    return new Uint8Array(await new Response(source).arrayBuffer());
+}
+/** Read raw bounded bytes without Workspace.fs's BOM-stripping UTF-8 path. */
+export function readBoundedWorkspaceText(provider, path, maximumBytes) {
+    const stat = provider.statSync(path);
+    if (!stat.isFile())
+        throw new Error(`Files path is not a file: ${path}`);
+    if (stat.size > maximumBytes) {
+        throw new Error(`Files path exceeds the ${String(maximumBytes)}-byte bound: ${path}`);
+    }
+    return decodeUtf8(new Uint8Array(provider.readRangeSync(path, 0, stat.size)), path);
+}
+/** Adapt native Workspace.fs at the one real file boundary. */
+export function createWorkspaceFilesPort(workspace, owner) {
+    return Object.freeze({
+        async read(input) {
+            const stat = await workspace.fs.stat(input.path);
+            if (!stat.isFile)
+                throw new Error(`Files path is not a file: ${input.path}`);
+            if (input.offset > stat.size) {
+                throw new Error(`Files read offset exceeds file size: ${input.path}`);
+            }
+            if (input.offset === stat.size) {
+                return {
+                    path: input.path,
+                    content: "",
+                    offset: input.offset,
+                    nextOffset: null,
+                    truncated: false,
+                };
+            }
+            const pageBytes = await readBytes(workspace, input.path, input.offset, Math.min(input.limit, stat.size - input.offset));
+            if (pageBytes.byteLength === 0) {
+                throw new Error(`Files path changed during read: ${input.path}`);
+            }
+            const page = decodeUtf8Page(pageBytes, input.path, input.offset + pageBytes.byteLength < stat.size);
+            const nextOffset = input.offset + page.byteLength;
+            return {
+                path: input.path,
+                content: page.content,
+                offset: input.offset,
+                nextOffset: nextOffset < stat.size ? nextOffset : null,
+                truncated: nextOffset < stat.size,
+            };
+        },
+        async list(input) {
+            const rows = await workspace.fs.readdir(input.path, {
+                limit: input.limit + 1,
+            });
+            const entries = rows.slice(0, input.limit).map((entry) => {
+                const path = childPath(input.path, entry.name);
+                return {
+                    path,
+                    name: entry.name,
+                    type: entryType(entry),
+                    size: entry.size,
+                    modifiedAt: entry.mtime,
+                };
+            });
+            return {
+                path: input.path,
+                entries,
+                truncated: rows.length > input.limit,
+            };
+        },
+        async glob(input) {
+            const rows = await workspace.fs.find(input.path, input.pattern, {
+                limit: input.limit + 1,
+            });
+            return {
+                path: input.path,
+                matches: rows.slice(0, input.limit).map((entry) => entry.path),
+                truncated: rows.length > input.limit,
+            };
+        },
+        async grep(input) {
+            const rows = await workspace.fs.grep(input.pattern, input.path, {
+                regex: input.regex,
+                ignoreCase: input.ignoreCase,
+                limit: input.limit + 1,
+            });
+            return {
+                path: input.path,
+                matches: rows.slice(0, input.limit).map((row) => ({
+                    path: row.path,
+                    line: row.line,
+                    text: row.text,
+                })),
+                truncated: rows.length > input.limit,
+            };
+        },
+        async replace(input) {
+            return replaceOutputSchema.parse(await owner.replaceFileIfUnchanged(input));
+        },
+    });
+}

package/dist/fleet/admission.d.ts

@@ -0,0 +1,14 @@
+import type { ComputerAction, ComputerGrant } from "./wire.js";
+/** The fleet's decision contains no host policy or host lookup. */
+export type ComputerAdmission = Readonly<{
+    kind: "admitted";
+}> | Readonly<{
+    kind: "Refused";
+    reason: "computer" | "action" | "expired";
+}>;
+/** Check authority supplied by the host at its door, using the fleet's clock. */
+export declare function checkComputerGrant(grant: ComputerGrant, request: Readonly<{
+    computerId: string;
+    action: ComputerAction;
+    now: number;
+}>): ComputerAdmission;

package/dist/fleet/admission.js

@@ -0,0 +1,10 @@
+/** Check authority supplied by the host at its door, using the fleet's clock. */
+export function checkComputerGrant(grant, request) {
+    if (grant.computerId !== request.computerId)
+        return { kind: "Refused", reason: "computer" };
+    if (!grant.actions.has(request.action))
+        return { kind: "Refused", reason: "action" };
+    if (request.now >= grant.expiresAt)
+        return { kind: "Refused", reason: "expired" };
+    return { kind: "admitted" };
+}

package/dist/fleet/backing.d.ts

@@ -0,0 +1,52 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type AttachedBackend, type HostedBacking } from "../computer-backends.js";
+import { type ComputerBackingChange, type ComputerBackendsProjection, type LocalBackendAttachInput, type LocalBackendDetachInput } from "./wire.js";
+/** Own backing records without consulting deployment configuration or a host. */
+export declare function createFleetBacking(owner: WatchdogSqliteOwner): {
+    ensure: () => void;
+    resolve: (computerId: string) => AttachedBackend[];
+    defaultBackings: () => ({
+        kind: "platform-container";
+    } | {
+        kind: "on-box-vm";
+        hostId: string;
+    })[] | null;
+    hasCreationRecord: (computerId: string) => boolean;
+    computerCreated: (computerId: string, raw: readonly HostedBacking[]) => ComputerBackendsProjection;
+    change: (actor: string, raw: ComputerBackingChange, config: Readonly<{
+        offered: ReadonlySet<HostedBacking["kind"]>;
+        computerIds: readonly string[];
+    }>) => {
+        revision: number;
+        projections: Readonly<{
+            computerId: string;
+            revision: number;
+            backends: readonly AttachedBackend[];
+        }>[];
+    };
+    attachLocal: (actor: string, raw: LocalBackendAttachInput) => {
+        backendId: string;
+        projections: Readonly<{
+            computerId: string;
+            revision: number;
+            backends: readonly AttachedBackend[];
+        }>[];
+    };
+    detachLocal: (actor: string, raw: LocalBackendDetachInput) => {
+        detached: boolean;
+        projections: Readonly<{
+            computerId: string;
+            revision: number;
+            backends: readonly AttachedBackend[];
+        }>[];
+    };
+    localOwners: (computerId: string) => ReadonlyMap<string, string>;
+    detachActorLocal: (actor: string) => {
+        detached: number;
+        projections: Readonly<{
+            computerId: string;
+            revision: number;
+            backends: readonly AttachedBackend[];
+        }>[];
+    };
+};

package/dist/fleet/backing.js

@@ -0,0 +1,242 @@
+import { z } from "zod";
+import { attachedBackendId, localBackendSchema, } from "../computer-backends.js";
+import { ComputerBackingError, computerBackingChangeSchema, hostedBackingsSchema, localBackendAttachSchema, localBackendDetachSchema, localBackendDetachRequestSchema, } from "./wire.js";
+const maximumLocalBackends = 8;
+const localRowSchema = z.strictObject({
+    computer_id: z.string(),
+    device_id: z.string(),
+    actor_id: z.string(),
+    public_key: z.string(),
+    host_label: z.string(),
+    folder_label: z.string(),
+    request_id: z.string(),
+});
+function mintDeviceId() {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    return Array.from(bytes, (byte) => alphabet.charAt(byte & 31)).join("");
+}
+/** Own backing records without consulting deployment configuration or a host. */
+export function createFleetBacking(owner) {
+    const { sql } = owner;
+    const ensure = () => {
+        sql.exec(`CREATE TABLE IF NOT EXISTS computer_fleet_backends (
+      scope TEXT PRIMARY KEY,
+      backings TEXT NOT NULL,
+      changed_at INTEGER NOT NULL,
+      changed_by TEXT NOT NULL
+    ) STRICT`);
+        sql.exec(`CREATE TABLE IF NOT EXISTS computer_fleet_backing_revision (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      revision INTEGER NOT NULL CHECK (revision >= 0)
+    ) STRICT`);
+        sql.exec(`CREATE TABLE IF NOT EXISTS computer_fleet_local_backends (
+      computer_id TEXT NOT NULL,
+      device_id TEXT NOT NULL,
+      actor_id TEXT NOT NULL,
+      public_key TEXT NOT NULL,
+      host_label TEXT NOT NULL,
+      folder_label TEXT NOT NULL,
+      request_id TEXT NOT NULL UNIQUE,
+      attached_at INTEGER NOT NULL,
+      PRIMARY KEY (computer_id, device_id)
+    ) STRICT`);
+        sql.exec(`CREATE TABLE IF NOT EXISTS computer_fleet_cancelled_attaches (
+      actor_id TEXT NOT NULL,
+      request_id TEXT NOT NULL,
+      PRIMARY KEY (actor_id, request_id)
+    ) STRICT`);
+    };
+    const revision = () => z
+        .number()
+        .int()
+        .nonnegative()
+        .parse(sql
+        .exec("SELECT revision FROM computer_fleet_backing_revision WHERE singleton=1")
+        .toArray()[0]?.revision ?? 0);
+    const advance = () => {
+        sql.exec("INSERT INTO computer_fleet_backing_revision VALUES (1,1) ON CONFLICT(singleton) DO UPDATE SET revision = revision + 1");
+    };
+    const stored = (scope) => {
+        const row = sql
+            .exec("SELECT backings FROM computer_fleet_backends WHERE scope = ?", scope)
+            .toArray()[0];
+        return row === undefined
+            ? null
+            : hostedBackingsSchema.parse(JSON.parse(z.string().parse(row.backings)));
+    };
+    const selectLocal = "SELECT computer_id, device_id, actor_id, public_key, host_label, folder_label, request_id FROM computer_fleet_local_backends";
+    const localRows = (computerId) => sql
+        .exec(`${selectLocal} WHERE computer_id = ? ORDER BY attached_at, device_id`, computerId)
+        .toArray()
+        .map((row) => localRowSchema.parse(row));
+    const localBackend = (row) => localBackendSchema.parse({
+        kind: "local",
+        deviceId: row.device_id,
+        publicKey: row.public_key,
+        hostLabel: row.host_label,
+        folderLabel: row.folder_label,
+    });
+    const resolve = (computerId) => {
+        const created = stored(`created:${computerId}`);
+        if (created === null)
+            throw new ComputerBackingError("unknown_computer");
+        return [
+            ...localRows(computerId).map(localBackend),
+            ...(stored(`computer:${computerId}`) ?? stored("fleet") ?? created),
+        ];
+    };
+    const projection = (computerId) => ({
+        computerId,
+        revision: revision(),
+        backends: resolve(computerId),
+    });
+    /** Creation takes a plain decision; retries cannot replace the first decision. */
+    const computerCreated = (computerId, raw) => {
+        const backings = hostedBackingsSchema.parse(raw);
+        return owner.transactionSync(() => {
+            sql.exec("INSERT INTO computer_fleet_backends VALUES (?,?,?,?) ON CONFLICT(scope) DO NOTHING", `created:${computerId}`, JSON.stringify(backings), Date.now(), "computer-create");
+            return projection(computerId);
+        });
+    };
+    /** The host passes the offered kinds; the fleet does not choose deployment policy. */
+    const change = (actor, raw, config) => {
+        const input = computerBackingChangeSchema.parse(raw);
+        if (input.backings?.some((backing) => !config.offered.has(backing.kind)))
+            throw new ComputerBackingError("not_enabled");
+        if (input.computerId === undefined && input.backings === null)
+            throw new ComputerBackingError("invalid");
+        const computerIds = input.computerId === undefined ? config.computerIds : [input.computerId];
+        return owner.transactionSync(() => {
+            for (const computerId of computerIds)
+                resolve(computerId);
+            const scope = input.computerId === undefined
+                ? "fleet"
+                : `computer:${input.computerId}`;
+            if (input.backings === null)
+                sql.exec("DELETE FROM computer_fleet_backends WHERE scope = ?", scope);
+            else
+                sql.exec("INSERT INTO computer_fleet_backends VALUES (?,?,?,?) ON CONFLICT(scope) DO UPDATE SET backings = excluded.backings, changed_at = excluded.changed_at, changed_by = excluded.changed_by", scope, JSON.stringify(input.backings), Date.now(), actor);
+            advance();
+            return { revision: revision(), projections: computerIds.map(projection) };
+        });
+    };
+    /**
+     * An actor attaches a machine. Replaying the same request returns the
+     * same backend; the device id is minted here, the key is the machine's.
+     */
+    const attachLocal = (actor, raw) => {
+        const input = localBackendAttachSchema.parse(raw);
+        if (stored(`created:${input.computerId}`) === null)
+            throw new ComputerBackingError("unknown_computer");
+        return owner.transactionSync(() => {
+            if (sql
+                .exec("SELECT 1 FROM computer_fleet_cancelled_attaches WHERE actor_id = ? AND request_id = ?", actor, input.requestId)
+                .toArray().length > 0)
+                throw new ComputerBackingError("request_conflict");
+            const prior = sql
+                .exec(`${selectLocal} WHERE request_id = ?`, input.requestId)
+                .toArray()[0];
+            if (prior !== undefined) {
+                const row = localRowSchema.parse(prior);
+                if (row.computer_id !== input.computerId ||
+                    row.actor_id !== actor ||
+                    row.public_key !== input.publicKey ||
+                    row.host_label !== input.hostLabel ||
+                    row.folder_label !== input.folderLabel)
+                    throw new ComputerBackingError("request_conflict");
+                return {
+                    backendId: attachedBackendId(localBackend(row)),
+                    projections: [],
+                };
+            }
+            if (localRows(input.computerId).length >= maximumLocalBackends)
+                throw new ComputerBackingError("local_limit");
+            const deviceId = mintDeviceId();
+            sql.exec("INSERT INTO computer_fleet_local_backends (computer_id, device_id, actor_id, public_key, host_label, folder_label, request_id, attached_at) VALUES (?,?,?,?,?,?,?,?)", input.computerId, deviceId, actor, input.publicKey, input.hostLabel, input.folderLabel, input.requestId, Date.now());
+            advance();
+            return {
+                backendId: `local-${deviceId}`,
+                projections: [projection(input.computerId)],
+            };
+        });
+    };
+    /** Which actor attached each local backend on a Computer. */
+    const localOwners = (computerId) => new Map(localRows(computerId).map((row) => [
+        `local-${row.device_id}`,
+        row.actor_id,
+    ]));
+    /**
+     * Detach one local backend. Only the actor who attached it may; a detach
+     * of one that is already gone is a no-op so an uncertain retry settles.
+     */
+    const detachLocal = (actor, raw) => {
+        const input = z
+            .union([localBackendDetachSchema, localBackendDetachRequestSchema])
+            .parse(raw);
+        if (stored(`created:${input.computerId}`) === null)
+            throw new ComputerBackingError("unknown_computer");
+        return owner.transactionSync(() => {
+            const row = "requestId" in input
+                ? sql
+                    .exec(`${selectLocal} WHERE computer_id = ? AND request_id = ?`, input.computerId, input.requestId)
+                    .toArray()[0]
+                : sql
+                    .exec(`${selectLocal} WHERE computer_id = ? AND device_id = ?`, input.computerId, input.backendId.slice("local-".length))
+                    .toArray()[0];
+            const attached = row === undefined ? undefined : localRowSchema.parse(row);
+            if (attached && attached.actor_id !== actor)
+                throw new ComputerBackingError("not_owner");
+            const requestId = "requestId" in input ? input.requestId : undefined;
+            if (requestId !== undefined) {
+                const cancelled = sql
+                    .exec("SELECT 1 FROM computer_fleet_cancelled_attaches WHERE actor_id = ? AND request_id = ?", actor, requestId)
+                    .toArray().length > 0;
+                if (!cancelled) {
+                    // Retain cancellation for the fleet lifetime: attach request IDs have no expiry.
+                    // The indexed per-actor ceiling bounds durable state without deleting protection.
+                    const count = z
+                        .number()
+                        .parse(sql
+                        .exec("SELECT count(*) AS count FROM computer_fleet_cancelled_attaches WHERE actor_id = ?", actor)
+                        .toArray()[0]?.count);
+                    if (count >= 4096)
+                        throw new ComputerBackingError("local_limit");
+                    sql.exec("INSERT INTO computer_fleet_cancelled_attaches VALUES (?,?)", actor, requestId);
+                }
+            }
+            if (attached === undefined)
+                return { detached: false, projections: [] };
+            sql.exec("DELETE FROM computer_fleet_local_backends WHERE computer_id = ? AND device_id = ?", input.computerId, attached.device_id);
+            advance();
+            return { detached: true, projections: [projection(input.computerId)] };
+        });
+    };
+    /** The host withdraws an actor's devices; membership policy stays with that host. */
+    const detachActorLocal = (actor) => owner.transactionSync(() => {
+        const computerIds = sql
+            .exec("SELECT computer_id FROM computer_fleet_local_backends WHERE actor_id = ?", actor)
+            .toArray()
+            .map((row) => z.string().parse(row.computer_id));
+        if (computerIds.length === 0)
+            return { detached: 0, projections: [] };
+        sql.exec("DELETE FROM computer_fleet_local_backends WHERE actor_id = ?", actor);
+        advance();
+        return {
+            detached: computerIds.length,
+            projections: [...new Set(computerIds)].map(projection),
+        };
+    });
+    return {
+        ensure,
+        resolve,
+        defaultBackings: () => stored("fleet"),
+        hasCreationRecord: (computerId) => stored(`created:${computerId}`) !== null,
+        computerCreated,
+        change,
+        attachLocal,
+        detachLocal,
+        localOwners,
+        detachActorLocal,
+    };
+}

package/dist/fleet/computers.d.ts

@@ -0,0 +1,62 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import type { HostedBacking } from "../computer-backends.js";
+import type { FleetActor, ComputerCreateRequest } from "./inventory-wire.js";
+/** Durable collection owner. Host decisions enter as data; projections leave in the result. */
+export declare function createFleetComputers(owner: WatchdogSqliteOwner, capacity: Readonly<{
+    limit: number;
+    retryAfterSeconds: number;
+}>): {
+    ensure: () => void;
+    read: (computerId: string) => import("./inventory-wire.js").FleetComputer | null;
+    list: (input: import("./inventory-wire.js").ComputerPage) => {
+        readonly computers: Readonly<{
+            computerId: string;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>[];
+        readonly nextOffset: number | null;
+    };
+    count: () => number;
+    ids: () => string[];
+    /** A replay preserves the original decision and stages nothing. */
+    create: (actor: FleetActor, request: ComputerCreateRequest, backings: readonly HostedBacking[]) => {
+        computer: Readonly<{
+            computerId: string;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        projections: Readonly<{
+            computerId: string;
+            revision: number;
+            backends: readonly import("../computer-backends.js").AttachedBackend[];
+        }>[];
+    };
+    readBacking: (computerId: string) => ({
+        kind: "platform-container";
+    } | {
+        kind: "on-box-vm";
+        hostId: string;
+    } | {
+        kind: "local";
+        deviceId: string;
+        publicKey: string;
+        hostLabel: string;
+        folderLabel: string;
+    })[] | null;
+    reserveSlot: (computerId: string) => Readonly<{
+        kind: "reserved";
+        runningComputers: number;
+    }> | Readonly<{
+        kind: "capacity";
+        runningComputers: number;
+        limit: number;
+        retryAfterSeconds: number;
+    }> | Readonly<{
+        kind: "unavailable";
+        cause: unknown;
+    }>;
+    releaseSlot: (computerId: string) => void;
+    runningCount: () => number;
+};

package/dist/fleet/computers.js

@@ -0,0 +1,35 @@
+import { createFleetInventory } from "./inventory.js";
+import { createFleetBacking } from "./backing.js";
+import { createFleetSlots } from "./slots.js";
+/** Durable collection owner. Host decisions enter as data; projections leave in the result. */
+export function createFleetComputers(owner, capacity) {
+    const inventory = createFleetInventory(owner);
+    const backing = createFleetBacking(owner);
+    const slots = createFleetSlots(owner, capacity);
+    return {
+        ensure: () => {
+            owner.transactionSync(() => {
+                inventory.ensure();
+                backing.ensure();
+                slots.ensure();
+            });
+        },
+        read: inventory.read,
+        list: inventory.list,
+        count: inventory.count,
+        ids: inventory.ids,
+        /** A replay preserves the original decision and stages nothing. */
+        create: (actor, request, backings) => owner.transactionSync(() => {
+            const prior = inventory.replay(actor, request);
+            if (prior !== null)
+                return { computer: prior, projections: [] };
+            const computer = inventory.create(actor, request);
+            const projection = backing.computerCreated(computer.computerId, backings);
+            return { computer, projections: [projection] };
+        }),
+        readBacking: (computerId) => inventory.read(computerId) === null ? null : backing.resolve(computerId),
+        reserveSlot: slots.reserve,
+        releaseSlot: slots.release,
+        runningCount: slots.count,
+    };
+}

package/dist/fleet/index.d.ts

@@ -0,0 +1,11 @@
+/** Host-neutral fleet contracts. Host policy is supplied as grants, never imported. */
+export { checkComputerGrant, type ComputerAdmission } from "./admission.js";
+export { createFleetBacking } from "./backing.js";
+export { computerActionSchema, computerProvenanceSchema, computerGrantSchema, computerStateSchema, computerFactSchema, ComputerBackingError, type ComputerAction, type ComputerProvenance, type ComputerGrant, type ComputerRuntimeState, type ComputerFact, type ComputerBackendsProjection, type ComputerBackingChange, type LocalBackendAttachInput, type LocalBackendDetachInput, } from "./wire.js";
+export { ComputerRuntimeUsage } from "./runtime-usage.js";
+export { computerUsageIntervalSchema, type ComputerUsageInterval, } from "./wire.js";
+export { createFleetInventory } from "./inventory.js";
+export { ComputerInventoryError, type FleetActor, type FleetComputer, } from "./inventory-wire.js";
+export { createFleetSlots } from "./slots.js";
+export { FleetLifecycle, FleetGrantRefused, type FleetLifecyclePorts, type FleetLifecycleFact, } from "./lifecycle.js";
+export { createFleetComputers } from "./computers.js";

package/dist/fleet/index.js

@@ -0,0 +1,11 @@
+/** Host-neutral fleet contracts. Host policy is supplied as grants, never imported. */
+export { checkComputerGrant } from "./admission.js";
+export { createFleetBacking } from "./backing.js";
+export { computerActionSchema, computerProvenanceSchema, computerGrantSchema, computerStateSchema, computerFactSchema, ComputerBackingError, } from "./wire.js";
+export { ComputerRuntimeUsage } from "./runtime-usage.js";
+export { computerUsageIntervalSchema, } from "./wire.js";
+export { createFleetInventory } from "./inventory.js";
+export { ComputerInventoryError, } from "./inventory-wire.js";
+export { createFleetSlots } from "./slots.js";
+export { FleetLifecycle, FleetGrantRefused, } from "./lifecycle.js";
+export { createFleetComputers } from "./computers.js";

package/dist/fleet/inventory-wire.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/** Opaque host identity; the fleet does not interpret the actor kind. */
+export type FleetActor = Readonly<{
+    kind: string;
+    id: string;
+}>;
+/** A Computer's public inventory record. */
+export type FleetComputer = Readonly<{
+    computerId: string;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+}>;
+/** A durable create receipt binds the complete request to its actor. */
+export type ComputerCreateRequest = Readonly<{
+    name?: string | undefined;
+    requestId: string;
+}>;
+/** Inventory pages retain stable ordering and a bounded response. */
+export declare const computerPageSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type ComputerPage = z.input<typeof computerPageSchema>;
+/** Inventory failures, independent of a host's public error mapping. */
+export declare class ComputerInventoryError extends Error {
+    readonly code: "partial_init" | "request_conflict" | "name_taken";
+    constructor(code: "partial_init" | "request_conflict" | "name_taken");
+}

package/dist/fleet/inventory-wire.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/** Inventory pages retain stable ordering and a bounded response. */
+export const computerPageSchema = z.strictObject({
+    limit: z.number().int().min(1).max(100).default(100),
+    offset: z.number().int().nonnegative().default(0),
+});
+/** Inventory failures, independent of a host's public error mapping. */
+export class ComputerInventoryError extends Error {
+    code;
+    constructor(code) {
+        super(`Computer inventory refused: ${code}`);
+        this.code = code;
+        this.name = "ComputerInventoryError";
+    }
+}

package/dist/fleet/inventory.d.ts

@@ -0,0 +1,24 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type FleetActor, type ComputerCreateRequest, type ComputerPage } from "./inventory-wire.js";
+import type { FleetComputer } from "./inventory-wire.js";
+/** Durable Computer inventory and replay receipts, without host admission policy. */
+export declare function createFleetInventory(options: Readonly<{
+    sql: WatchdogSqliteOwner["sql"];
+    transactionSync: <T>(body: () => T) => T;
+}>): {
+    ensure: () => void;
+    replay: (actor: FleetActor, request: ComputerCreateRequest) => FleetComputer | null;
+    create: (actor: FleetActor, request: ComputerCreateRequest) => FleetComputer;
+    read: (computerId: string) => FleetComputer | null;
+    list: (input: ComputerPage) => {
+        readonly computers: Readonly<{
+            computerId: string;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>[];
+        readonly nextOffset: number | null;
+    };
+    ids: () => string[];
+    count: () => number;
+};