@gestaltrun/dsh-workspace-bundle 0.0.0-stage → 0.1.1

package/lib/types/journal.js

@@ -0,0 +1,109 @@
+/** Durable upgrade journal: staging → updating → swap → verify → commit, with crash recovery. */
+import { basename, dirname, join } from 'node:path';
+import { bundledDirectory } from "./paths.js";
+import { WorkspaceBundleError } from "./errors.js";
+const IDLE = {
+    phase: 'idle',
+    fromDigest: null,
+    toDigest: null,
+    pluginVersion: null,
+    stagingPath: null,
+    backupPath: null,
+    swapComplete: false,
+};
+/** @returns a journal with no in-flight replacement. */
+export function idleJournal() {
+    return IDLE;
+}
+/**
+ * @param parent - journal root from Spec.
+ * @param identity - bundled Workspace.
+ */
+export function journalPath(parent, identity) {
+    return join(bundledDirectory(parent, identity), 'journal.json');
+}
+/**
+ * @param parent - journal root from Spec.
+ * @param identity - bundled Workspace.
+ */
+export function recordPath(parent, identity) {
+    return join(bundledDirectory(parent, identity), 'record.json');
+}
+async function writeJson(fs, path, value) {
+    const tmp = `${path}.tmp`;
+    await fs.writeFile(tmp, `${JSON.stringify(value)}\n`);
+    await fs.rename(tmp, path);
+}
+/**
+ * Persist the product record.
+ * @param fs - filesystem.
+ * @param path - record.json path.
+ * @param record - value.
+ */
+export async function writeRecord(fs, path, record) {
+    await writeJson(fs, path, record);
+}
+/**
+ * Read a product record when present.
+ * @param fs - filesystem.
+ * @param path - record.json path.
+ */
+export async function readRecord(fs, path) {
+    if (!await fs.exists(path))
+        return undefined;
+    const value = JSON.parse((await fs.readFile(path)).toString('utf8'));
+    if (value.version !== 1)
+        throw new Error(`workspace-bundle: unsupported record version ${String(value.version)}`);
+    return value;
+}
+async function canonicalPath(fs, path) {
+    try {
+        return await fs.realpath(path);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT' || dirname(path) === path)
+            throw error;
+        // A replacement can leave root or staging absent; existing ancestors still resolve directory aliases.
+        return join(await canonicalPath(fs, dirname(path)), basename(path));
+    }
+}
+/**
+ * Reject stored paths whose canonical locations differ from the identity's controlled directories.
+ * @param fs - filesystem used by recovery, including realpath resolution.
+ * @param record - stored product record.
+ * @param root - materialize directory derived from the requested identity and current Spec.
+ * @returns fulfills when every stored path has the same canonical location as its controlled directory.
+ * @throws {WorkspaceBundleError} Before recovery mutates files when a stored path differs.
+ */
+export async function assertRecordPaths(fs, record, root) {
+    for (const [stored, controlled] of [
+        [record.path, root],
+        [record.journal.stagingPath, `${root}.staging`],
+        [record.journal.backupPath, `${root}.backup`],
+    ]) {
+        if (stored !== null && await canonicalPath(fs, stored) !== await canonicalPath(fs, controlled)) {
+            throw new WorkspaceBundleError('WORKSPACE_BUNDLE_PATH_TRAVERSAL', `stored Workspace paths must match the canonical controlled directory ${controlled}`);
+        }
+    }
+}
+/**
+ * Persist the journal as part of the product record.
+ * @param fs - filesystem.
+ * @param path - record.json path.
+ * @param record - current record.
+ * @param journal - next journal.
+ */
+export async function writeJournal(fs, path, record, journal) {
+    const next = { ...record, journal };
+    await writeRecord(fs, path, next);
+    return next;
+}
+/**
+ * Mark a replacement as committed: idle journal, new digest and plugin version.
+ * @param record - current record.
+ * @param digest - verified tree digest.
+ * @param pluginVersion - packaged plugin version.
+ */
+export function committedRecord(record, digest, pluginVersion) {
+    return { ...record, pluginVersion, templateDigest: digest, journal: idleJournal(), lastFailure: null };
+}

package/lib/types/local-host-identity.d.ts

@@ -0,0 +1,65 @@
+import type { MerchantHostIdentity } from '@gestaltrun/dsh-merchant-account';
+import type { WorkspaceAgentConfigHostId } from './agent-config-observation.ts';
+/** Server and member whose local modules report under one identity; the server keeps one current local Host per member and module. */
+export type LocalHostIdentityScope = Pick<MerchantHostIdentity, 'serverOrigin' | 'userId'>;
+/** Identity read from its owning module when a queued publish commits. */
+export interface LocalHostIdentityValue {
+    readonly hostId: WorkspaceAgentConfigHostId;
+    /** The server confirmed this identity against the installation key; a confirmed identity is never replaced. */
+    readonly confirmed: boolean;
+}
+/** Shared identity exposed by the WorkspaceBundles owner. */
+export interface LocalHostIdentity {
+    /** @param scope - signed-in server and member. @returns the persisted identity, or undefined before its owner published one. */
+    get(scope: LocalHostIdentityScope): WorkspaceAgentConfigHostId | undefined;
+    /**
+     * Persist the owner's identity after earlier publishes; readers observe it only after the write succeeds.
+     * A different identity replaces only an unconfirmed one, so readers never return to an identity the server already replaced.
+     * @param scope - member the identity belongs to.
+     * @param read - owner's identity for that scope, read when this publish commits; undefined skips the write, for an owner disposed meanwhile.
+     * @returns whether readers now observe a different identity.
+     */
+    publish(scope: LocalHostIdentityScope, read: () => LocalHostIdentityValue | undefined): Promise<boolean>;
+}
+/** Load stops instead of letting modules report under their own identities, which the server may already have replaced. */
+export declare class LocalHostIdentityLoadError extends Error {
+    /** @param path - state file that could not be read or parsed. @param cause - underlying read or validation failure. */
+    constructor(path: string, cause: unknown);
+}
+/** The previous identity remains visible; the owner reports this failure and keeps its own reporting. */
+export declare class LocalHostIdentityWriteError extends Error {
+    /** @param cause - underlying private filesystem failure. */
+    constructor(cause: unknown);
+}
+/** Loads synchronously so the first module report already reads the persisted identity. */
+export declare class LocalHostIdentityState implements LocalHostIdentity {
+    private readonly path;
+    private state;
+    private writes;
+    /** @param path - owner-only state file; null creates an explicit in-memory owner. An unreadable or invalid file fails load instead of exposing no identity. */
+    constructor(path: string | null);
+    /** @inheritdoc */
+    get(scope: LocalHostIdentityScope): WorkspaceAgentConfigHostId | undefined;
+    /** @inheritdoc */
+    publish(scope: LocalHostIdentityScope, read: () => LocalHostIdentityValue | undefined): Promise<boolean>;
+    private save;
+}
+/** Merchant session and WorkspaceBundles members read by {@link sharedLocalHostId}; a Host context satisfies it. */
+export interface LocalHostIdentitySources {
+    readonly merchantAccount: {
+        captureIdentity(): {
+            readonly identity: LocalHostIdentityScope;
+        } | null;
+    };
+    readonly workspaceBundles: {
+        readonly localHostIdentity: LocalHostIdentity;
+    };
+}
+/**
+ * Identity getter for a local module reporter: the shared identity of the signed-in member, otherwise the module's own identity.
+ * Pass it as `hostId` and keep the fallback fixed; once an identity is shared, the reporter never returns to the fallback.
+ * @param ctx - context with the merchant session and WorkspaceBundles.
+ * @param fallback - module identity used before any local module published a shared one.
+ * @returns getter read before each registration.
+ */
+export declare function sharedLocalHostId(ctx: LocalHostIdentitySources, fallback: WorkspaceAgentConfigHostId): () => WorkspaceAgentConfigHostId;

package/lib/types/local-host-identity.js

@@ -0,0 +1,87 @@
+/** One durable local Host identity per server and member, reused by every local module observation. */
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+import { z } from 'zod';
+const State = z.strictObject({ version: z.literal(1), scopes: z.record(z.string().regex(/^[a-f0-9]{64}$/u), z.strictObject({ hostId: z.uuid(), confirmed: z.boolean() })) });
+function keyOf(scope) {
+    return createHash('sha256').update(JSON.stringify([scope.serverOrigin, scope.userId])).digest('hex');
+}
+/** Load stops instead of letting modules report under their own identities, which the server may already have replaced. */
+export class LocalHostIdentityLoadError extends Error {
+    /** @param path - state file that could not be read or parsed. @param cause - underlying read or validation failure. */
+    constructor(path, cause) {
+        super(`The shared local Host identity file ${path} cannot be read or is invalid. Restore it from a backup or fix its permissions; deleting it makes local modules report under their own identities and may require reactivating local hosting.`, { cause });
+    }
+}
+/** The previous identity remains visible; the owner reports this failure and keeps its own reporting. */
+export class LocalHostIdentityWriteError extends Error {
+    /** @param cause - underlying private filesystem failure. */
+    constructor(cause) { super('LOCAL_HOST_IDENTITY_WRITE_FAILED', { cause }); }
+}
+/** Loads synchronously so the first module report already reads the persisted identity. */
+export class LocalHostIdentityState {
+    path;
+    state = { version: 1, scopes: {} };
+    writes = Promise.resolve();
+    /** @param path - owner-only state file; null creates an explicit in-memory owner. An unreadable or invalid file fails load instead of exposing no identity. */
+    constructor(path) {
+        this.path = path;
+        if (path === null)
+            return;
+        try {
+            this.state = State.parse(JSON.parse(readFileSync(path, 'utf8')));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw new LocalHostIdentityLoadError(path, error);
+        }
+    }
+    /** @inheritdoc */
+    get(scope) {
+        const entry = this.state.scopes[keyOf(scope)];
+        return entry === undefined ? undefined : brandString(entry.hostId);
+    }
+    /** @inheritdoc */
+    publish(scope, read) {
+        const work = this.writes.then(async () => {
+            const key = keyOf(scope), previous = this.state.scopes[key], next = read();
+            if (next === undefined)
+                return false;
+            if (previous !== undefined && (previous.hostId === next.hostId ? previous.confirmed || !next.confirmed : previous.confirmed))
+                return false;
+            const state = { ...this.state, scopes: { ...this.state.scopes, [key]: { hostId: next.hostId, confirmed: next.confirmed } } };
+            await this.save(state);
+            this.state = state;
+            return previous?.hostId !== next.hostId;
+        });
+        // Each returned publish reports its own failure; later publishes must still run.
+        this.writes = work.then(() => { }, (error) => { void error; });
+        return work;
+    }
+    async save(state) {
+        if (this.path === null)
+            return;
+        try {
+            await writeFileAtomic(this.path, JSON.stringify(state) + '\n', { mode: 0o600, dirMode: 0o700 });
+        }
+        catch (error) {
+            throw new LocalHostIdentityWriteError(error);
+        }
+    }
+}
+/**
+ * Identity getter for a local module reporter: the shared identity of the signed-in member, otherwise the module's own identity.
+ * Pass it as `hostId` and keep the fallback fixed; once an identity is shared, the reporter never returns to the fallback.
+ * @param ctx - context with the merchant session and WorkspaceBundles.
+ * @param fallback - module identity used before any local module published a shared one.
+ * @returns getter read before each registration.
+ */
+export function sharedLocalHostId(ctx, fallback) {
+    return () => {
+        const scope = ctx.merchantAccount.captureIdentity()?.identity;
+        return (scope === undefined ? undefined : ctx.workspaceBundles.localHostIdentity.get(scope)) ?? fallback;
+    };
+}

package/lib/types/local-host-replacement.d.ts

@@ -0,0 +1,49 @@
+import type { AgentConfigModule } from './agent-config-contract/agent-configs.ts';
+import type { MerchantHostIdentity } from '@gestaltrun/dsh-merchant-account';
+/** Server, member and selected shop whose local modules share one activation decision. */
+export type LocalHostMember = Pick<MerchantHostIdentity, 'serverOrigin' | 'userId' | 'currentTenantId'>;
+/** Shared member fence exposed by the WorkspaceBundles owner. */
+export interface LocalHostReplacement {
+    /** @param member - current member. @returns whether explicit activation is required. */
+    isReplaced(member: LocalHostMember): boolean;
+    /** @param listener - reacts to changes. @returns its disposer. */
+    subscribe(listener: () => void): () => void;
+    /** Stop immediately in memory, then persist; a rejection keeps the stop and permits the next call to retry. @param member - rejected member. @returns completion of the durable write. */
+    markReplaced(member: LocalHostMember): Promise<void>;
+    /** @param member - member whose two modules have acknowledged activation. @returns completion of the durable clear; failure keeps reception stopped. */
+    activate(member: LocalHostMember): Promise<void>;
+    /** @param member - current member. @param module - legacy source. @returns whether its state was imported. */
+    migrated(member: LocalHostMember, module: AgentConfigModule): boolean;
+    /** @param member - current member. @param module - legacy source. @param replaced - previous stop flag. @returns completion before any legacy marker may be removed. */
+    importLegacy(member: LocalHostMember, module: AgentConfigModule, replaced: boolean): Promise<void>;
+}
+/** The memory fence remains active; callers retain fallback markers and report this failure. */
+export declare class LocalHostReplacementWriteError extends Error {
+    /** @param cause - underlying private filesystem failure. */
+    constructor(cause: unknown);
+}
+/** Shared by module reporters, lease supervision and checkpoints within one Host. */
+export declare class LocalHostReplacementState implements LocalHostReplacement {
+    private readonly path;
+    private state;
+    private readonly listeners;
+    private persisted;
+    private writes;
+    private readonly rejections;
+    /** @param path - owner-only state file; null creates an explicit in-memory owner. */
+    constructor(path: string | null);
+    /** @param member - current authenticated member. @returns whether explicit activation is required. */
+    isReplaced(member: LocalHostMember): boolean;
+    /** @param listener - reacts to a changed fence. @returns its disposer. */
+    subscribe(listener: () => void): () => void;
+    /** @param member - rejected member. Stops consumers before persistence starts. @returns durable completion; failure permits a later retry. */
+    markReplaced(member: LocalHostMember): Promise<void>;
+    /** @param member - member whose two module registrations have both been acknowledged. @returns durable completion, unless a newer rejection requires another activation. */
+    activate(member: LocalHostMember): Promise<void>;
+    /** @param member - current member. @param module - module whose legacy files were inspected. @returns whether migration is complete. */
+    migrated(member: LocalHostMember, module: AgentConfigModule): boolean;
+    /** @param member - current member. @param module - legacy source. @param replaced - whether any prior installation was stopped. @returns durable completion before the caller removes fallback flags. */
+    importLegacy(member: LocalHostMember, module: AgentConfigModule, replaced: boolean): Promise<void>;
+    private enqueue;
+    private save;
+}

package/lib/types/local-host-replacement.js

@@ -0,0 +1,112 @@
+/** One durable replacement fence per authenticated shop member, independent of installation and module. */
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+import { z } from 'zod';
+const State = z.strictObject({ version: z.literal(1), replaced: z.array(z.string().regex(/^[a-f0-9]{64}$/u)), migrated: z.array(z.string().regex(/^[a-f0-9]{64}\/(cs-hosting|resource-intake)$/u)) });
+function keyOf(member) {
+    return createHash('sha256').update(JSON.stringify([member.serverOrigin, member.userId, member.currentTenantId])).digest('hex');
+}
+/** The memory fence remains active; callers retain fallback markers and report this failure. */
+export class LocalHostReplacementWriteError extends Error {
+    /** @param cause - underlying private filesystem failure. */
+    constructor(cause) { super('LOCAL_HOST_REPLACEMENT_WRITE_FAILED', { cause }); }
+}
+/** Shared by module reporters, lease supervision and checkpoints within one Host. */
+export class LocalHostReplacementState {
+    path;
+    state = { version: 1, replaced: [], migrated: [] };
+    listeners = new Set();
+    persisted = this.state;
+    writes = Promise.resolve();
+    rejections = new Map();
+    /** @param path - owner-only state file; null creates an explicit in-memory owner. */
+    constructor(path) {
+        this.path = path;
+        if (path === null)
+            return;
+        try {
+            this.state = State.parse(JSON.parse(readFileSync(path, 'utf8')));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        this.persisted = this.state;
+    }
+    /** @param member - current authenticated member. @returns whether explicit activation is required. */
+    isReplaced(member) { return this.state.replaced.includes(keyOf(member)); }
+    /** @param listener - reacts to a changed fence. @returns its disposer. */
+    subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+    /** @param member - rejected member. Stops consumers before persistence starts. @returns durable completion; failure permits a later retry. */
+    markReplaced(member) {
+        const key = keyOf(member);
+        this.rejections.set(key, (this.rejections.get(key) ?? 0) + 1);
+        if (!this.state.replaced.includes(key)) {
+            this.state = { ...this.state, replaced: [...this.state.replaced, key] };
+            for (const listener of this.listeners)
+                listener();
+        }
+        if (this.persisted === this.state)
+            return Promise.resolve();
+        return this.enqueue(async () => {
+            const state = this.state;
+            await this.save(state);
+            this.persisted = state;
+        });
+    }
+    /** @param member - member whose two module registrations have both been acknowledged. @returns durable completion, unless a newer rejection requires another activation. */
+    activate(member) {
+        const key = keyOf(member), rejection = this.rejections.get(key);
+        if (!this.state.replaced.includes(key))
+            return Promise.resolve();
+        this.persisted = undefined;
+        return this.enqueue(async () => {
+            const previous = this.state;
+            if (!previous.replaced.includes(key))
+                return;
+            if (this.rejections.get(key) !== rejection)
+                throw new Error('LOCAL_HOST_REPLACED');
+            const next = { ...previous, replaced: previous.replaced.filter(value => value !== key) };
+            await this.save(next);
+            if (this.state !== previous || this.rejections.get(key) !== rejection) {
+                await this.save(this.state);
+                throw new Error('LOCAL_HOST_REPLACED');
+            }
+            this.persisted = this.state = next;
+            for (const listener of this.listeners)
+                listener();
+        });
+    }
+    /** @param member - current member. @param module - module whose legacy files were inspected. @returns whether migration is complete. */
+    migrated(member, module) { return this.state.migrated.includes(`${keyOf(member)}/${module}`); }
+    /** @param member - current member. @param module - legacy source. @param replaced - whether any prior installation was stopped. @returns durable completion before the caller removes fallback flags. */
+    async importLegacy(member, module, replaced) {
+        if (replaced)
+            await this.markReplaced(member);
+        if (this.migrated(member, module))
+            return;
+        this.state = { ...this.state, migrated: [...this.state.migrated, `${keyOf(member)}/${module}`] };
+        await this.enqueue(async () => {
+            const state = this.state;
+            await this.save(state);
+            this.persisted = state;
+        });
+    }
+    enqueue(write) {
+        const work = this.writes.then(write);
+        // Each returned operation reports its own failure; later writes must still run.
+        this.writes = work.catch((error) => { void error; });
+        return work;
+    }
+    async save(state) {
+        if (this.path === null)
+            return;
+        try {
+            await writeFileAtomic(this.path, JSON.stringify(state) + '\n', { mode: 0o600, dirMode: 0o700 });
+        }
+        catch (error) {
+            throw new LocalHostReplacementWriteError(error);
+        }
+    }
+}

package/lib/types/paths.d.ts

@@ -0,0 +1,26 @@
+import type { WorkspaceBundleId, WorkspaceBundleKey } from '@deepseek-ai/dsh-workspace/types';
+import type { WorkspaceBundleIdentity } from './types.ts';
+/**
+ * Encode one branded identity as a single path segment.
+ * @param value - bundle id or workspace key.
+ * @param field - diagnostic name.
+ * @returns the same spelling when it is a controlled segment.
+ * @throws {WorkspaceBundleError} When the value could traverse or collide with `.` / `..`.
+ */
+export declare function encodeBundleSegment(value: string, field: 'bundleId' | 'workspaceKey'): string;
+/**
+ * Join a parent with `{bundleId}/{workspaceKey}`.
+ * @param parent - absolute parent already validated by Config.
+ * @param identity - branded pair.
+ * @returns the joined path using the host separator.
+ */
+export declare function bundledDirectory(parent: string, identity: WorkspaceBundleIdentity): string;
+/**
+ * Reject a template-relative path that leaves the root, is absolute, or uses a reserved segment.
+ * @param relativePath - POSIX relative path from the manifest.
+ * @returns the same spelling.
+ * @throws {WorkspaceBundleError} On traversal, absolute paths, empty segments, or backslashes.
+ */
+export declare function assertTemplateRelativePath(relativePath: string): string;
+/** @param bundleId - branded bundle identity. @param workspaceKey - branded workspace key. */
+export declare function identityOf(bundleId: WorkspaceBundleId, workspaceKey: WorkspaceBundleKey): WorkspaceBundleIdentity;

package/lib/types/paths.js

@@ -0,0 +1,48 @@
+/** Controlled encoding of branded Workspace bundle identities into Home path segments. */
+import { join, posix, sep } from 'node:path';
+import { WorkspaceBundleError } from "./errors.js";
+const SEGMENT = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+/**
+ * Encode one branded identity as a single path segment.
+ * @param value - bundle id or workspace key.
+ * @param field - diagnostic name.
+ * @returns the same spelling when it is a controlled segment.
+ * @throws {WorkspaceBundleError} When the value could traverse or collide with `.` / `..`.
+ */
+export function encodeBundleSegment(value, field) {
+    if (!SEGMENT.test(value) || value === '.' || value === '..' || value.includes(sep) || value.includes(posix.sep) || value.includes('\0')) {
+        throw new WorkspaceBundleError('WORKSPACE_BUNDLE_IDENTITY_INVALID', `${field} ${JSON.stringify(value)} is not a controlled path segment`);
+    }
+    return value;
+}
+/**
+ * Join a parent with `{bundleId}/{workspaceKey}`.
+ * @param parent - absolute parent already validated by Config.
+ * @param identity - branded pair.
+ * @returns the joined path using the host separator.
+ */
+export function bundledDirectory(parent, identity) {
+    return join(parent, encodeBundleSegment(identity.bundleId, 'bundleId'), encodeBundleSegment(identity.workspaceKey, 'workspaceKey'));
+}
+/**
+ * Reject a template-relative path that leaves the root, is absolute, or uses a reserved segment.
+ * @param relativePath - POSIX relative path from the manifest.
+ * @returns the same spelling.
+ * @throws {WorkspaceBundleError} On traversal, absolute paths, empty segments, or backslashes.
+ */
+export function assertTemplateRelativePath(relativePath) {
+    if (relativePath === '' || relativePath.startsWith('/') || relativePath.includes('\\') || relativePath.includes('\0')) {
+        throw new WorkspaceBundleError('WORKSPACE_BUNDLE_PATH_TRAVERSAL', `template path ${JSON.stringify(relativePath)} is not a relative POSIX path`);
+    }
+    const parts = relativePath.split('/');
+    if (parts.some(part => part === '' || part === '.' || part === '..')) {
+        throw new WorkspaceBundleError('WORKSPACE_BUNDLE_PATH_TRAVERSAL', `template path ${JSON.stringify(relativePath)} contains a reserved segment`);
+    }
+    return relativePath;
+}
+/** @param bundleId - branded bundle identity. @param workspaceKey - branded workspace key. */
+export function identityOf(bundleId, workspaceKey) {
+    encodeBundleSegment(bundleId, 'bundleId');
+    encodeBundleSegment(workspaceKey, 'workspaceKey');
+    return { bundleId, workspaceKey };
+}

package/lib/types/provider.d.ts

@@ -0,0 +1,83 @@
+import { Context } from '@deepseek-ai/cordis';
+import type { Workspace, WorkspaceId } from '@deepseek-ai/dsh-workspace/types';
+import { Config } from './config.ts';
+import { WorkspaceBundles } from './definition.ts';
+import type { WorkspaceAgentConfigHandle, WorkspaceAgentConfigSource, WorkspaceAgentConfigState } from './agent-config-types.ts';
+import type { WorkspaceBundleCrashPoint, WorkspaceBundleFs, WorkspaceBundleIdentity, WorkspaceBundleRecord, WorkspaceBundlesSpec, WorkspaceTemplate } from './types.ts';
+/** Provider for packaged Workspace templates. */
+export declare class GestaltWorkspaceBundles extends WorkspaceBundles {
+    static inject: string[];
+    static Config: import("@deepseek-ai/schemastery").default<Config, import("./config.ts").ResolvedConfig>;
+    /** Deployment settings resolved at load. */
+    readonly spec: WorkspaceBundlesSpec;
+    private readonly fs;
+    private readonly templates;
+    private readonly agentConfigSources;
+    private readonly records;
+    private readonly leases;
+    private readonly waiters;
+    private chain;
+    private readonly recycle;
+    private readonly recycleWork;
+    private readonly contentDrains;
+    private closed;
+    private readonly download;
+    /**
+     * @param ctx - Host context with the Workspace registry.
+     * @param config - raw row settings.
+     * @param options.fs - filesystem; tests inject crashes through `crashAt`.
+     * @param options.crashAt - single crash point; production omits it.
+     * @param options.fetch - 文件 HTTP 传输；默认使用 Host fetch。
+     */
+    constructor(ctx: Context, config?: Config, options?: {
+        fs?: WorkspaceBundleFs;
+        crashAt?: WorkspaceBundleCrashPoint;
+        fetch?: typeof fetch;
+    });
+    /** @inheritdoc */
+    register(template: WorkspaceTemplate): () => void;
+    /** @inheritdoc */
+    ensure(identity: WorkspaceBundleIdentity): Promise<Workspace>;
+    /** @inheritdoc */
+    registerAgentConfigSource(source: WorkspaceAgentConfigSource): () => Promise<void>;
+    /** @inheritdoc */
+    agentConfig(identity: WorkspaceBundleIdentity): WorkspaceAgentConfigState | undefined;
+    /** @inheritdoc */
+    refreshAgentConfig(identity: WorkspaceBundleIdentity): Promise<void>;
+    /** @inheritdoc */
+    acquire(workspaceId: WorkspaceId): Promise<() => void>;
+    /** @inheritdoc */
+    acquireAgentConfig(identity: WorkspaceBundleIdentity): Promise<WorkspaceAgentConfigHandle>;
+    private contentHandle;
+    private acquireOne;
+    private holdLease;
+    /** @inheritdoc */
+    record(identity: WorkspaceBundleIdentity): WorkspaceBundleRecord | undefined;
+    /** @inheritdoc */
+    pathOf(identity: WorkspaceBundleIdentity): string;
+    /**
+     * Replay an interrupted journal before serving the Workspace.
+     * @param identity - branded pair.
+     * @throws {WorkspaceBundleError} Before any rename or deletion if stored paths differ from this identity's controlled paths.
+     * @throws {AgentConfigError} After physical recovery when committed content fails compatibility or consumer validation.
+     */
+    recover(identity: WorkspaceBundleIdentity): Promise<Workspace | undefined>;
+    private enqueue;
+    private ensureOne;
+    private rollbackAgentConfig;
+    private requireTemplate;
+    private stagingOf;
+    private backupOf;
+    private recordFile;
+    private loadStored;
+    private recoverOne;
+    private workspaceOf;
+    private restoreOld;
+    private finishNew;
+    private replace;
+    private commit;
+    private quiesce;
+    private scheduleRecycle;
+    private prepareBackup;
+}
+export default GestaltWorkspaceBundles;