@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/channel/model-switch.js

@@ -0,0 +1,116 @@
+import { randomUUID } from 'node:crypto';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { t } from '../../i18n.js';
+import { writeModelPref } from '../../modelPrefs.js';
+import { touchSession } from '../../sessionHistory.js';
+import { liveSessionCreateOptions, sliceLiveSessionSeed } from '../compat/index.js';
+import { composePreset, runningPresetOf } from '../presets.js';
+import { reserveNewSession } from '../../sessionMounts.js';
+import { attachSessionToWorkspace } from '../workspace.js';
+import { resetSessionProjection } from './session-reset.js';
+/** Model-route adoption transaction. It settles compaction before its fork snapshot and owns the post-commit reset. */
+export function createModelSwitchAction(ctx, state, deps) {
+    return async (provider, model) => {
+        const adoption = deps.binding.capture();
+        if (state.working) {
+            deps.notify(t('model-switch-while-working'), { color: 'warning' });
+            return false;
+        }
+        const agents = ctx.get('agents');
+        if (agents === undefined) {
+            deps.notify(t('model-switch-unavailable'), { color: 'error' });
+            return false;
+        }
+        let seed;
+        try {
+            // A compaction checkpoint may not settle after the model fork snapshot.
+            await deps.settleCompaction();
+            // No boundary = the whole source log (continue the conversation). Slice
+            // the SOURCE snapshot: sessions.fork() registers a real child, and its
+            // snapshot length is not the inherited cut.
+            seed = sliceLiveSessionSeed(deps.binding.agent.session);
+        }
+        catch (error) {
+            deps.notify(t('model-switch-fork-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error' });
+            return false;
+        }
+        const childId = SessionId(randomUUID());
+        // Announce the id before the factory: from the moment `agents.create`
+        // returns this process holds the only write handle on a log the publisher
+        // will not name until its next beat.
+        const { reservation } = await reserveNewSession(String(childId));
+        const composed = await composePreset(ctx, runningPresetOf(deps.binding.agent.session));
+        let handle;
+        try {
+            handle = await deps.binding.prepare(adoption, () => agents.create(liveSessionCreateOptions({
+                sessionId: childId,
+                seed,
+                runtimeSession: deps.binding.agent.session,
+                inheritedCount: seed.length,
+                cwd: state.cwd,
+                parentSession: deps.binding.agent.session.id,
+                agentPreset: composed.agentPreset,
+                agentOptions: { provider, model },
+                setup: composed.setup,
+            })));
+        }
+        catch (error) {
+            reservation.abandon();
+            deps.notify(t('model-switch-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            return false;
+        }
+        try {
+            await attachSessionToWorkspace(ctx, state.cwd, childId);
+        }
+        catch (error) {
+            deps.notify(t('model-switch-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
+        }
+        if (!deps.binding.isCurrent(adoption) || !deps.owner.current()) {
+            await deps.binding.abandon(handle);
+            reservation.abandon();
+            return false;
+        }
+        let committed = false;
+        try {
+            const result = deps.binding.adopt(handle, adoption, (_previous, disposePrevious) => {
+                resetSessionProjection(state, deps.rowIds, deps.resetProjector, deps.resetSubagents, deps.resetJobs);
+                state.status = handle.agent.status;
+                state.agentId = handle.agent.id;
+                state.sessionId = handle.agent.session.id;
+                state.agentPreset = composed.agentPreset;
+                state.provider = provider;
+                state.model = model;
+                state.contextWindow = undefined;
+                state.effortLevels = undefined;
+                state.reasoningEffort = undefined;
+                deps.dropModelCompletion();
+                deps.replay(seed);
+                deps.settleReplay();
+                state.working = handle.agent.status === 'running';
+                // Reset the input FIFO and pending-decision indicators BEFORE the first
+                // emit: a submit from a session-changed subscriber must not chain onto
+                // the replaced session's parked promise (main's bind → clear → refresh
+                // order).
+                deps.clearStagedImages();
+                deps.bindAgent();
+                deps.refreshCommands();
+                void deps.refreshLoadedContext();
+                void deps.refreshSkillCommands();
+                touchSession(childId);
+                state.emit();
+                disposePrevious('dispose');
+                if (!writeModelPref(provider, model))
+                    deps.notify(t('model-pref-write-failed'), { color: 'warning' });
+                return true;
+            });
+            committed = true;
+            return result;
+        }
+        finally {
+            if (committed)
+                reservation.settle();
+            else
+                reservation.abandon();
+        }
+    };
+}

package/lib/types/dsh-adapter/channel/notifications.d.ts

@@ -0,0 +1,9 @@
+import type { ChannelOwner } from './owner.js';
+import type { ChannelUi } from '../../adapter/ports/channel-ui.js';
+import type { NotificationItem } from './types.js';
+/** Own expiry and explicit dismissal in the same bounded notification scope. */
+export declare function createChannelNotifications(state: () => {
+    notifications: NotificationItem[];
+    emit(): void;
+}, owner: ChannelOwner): ChannelUi['notify'];
+//# sourceMappingURL=notifications.d.ts.map

package/lib/types/dsh-adapter/channel/notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAA;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,gFAAgF;AAChF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM;IAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC;IAAC,IAAI,IAAI,IAAI,CAAA;CAAE,EAChE,KAAK,EAAE,YAAY,GAClB,SAAS,CAAC,QAAQ,CAAC,CAiBrB"}

package/lib/types/dsh-adapter/channel/notifications.js

@@ -0,0 +1,24 @@
+/** Own expiry and explicit dismissal in the same bounded notification scope. */
+export function createChannelNotifications(state, owner) {
+    let sequence = 0;
+    return (text, options = {}) => {
+        owner.assertActive();
+        const item = { id: sequence++, text, color: options.color, timeoutMs: options.timeoutMs ?? 4000 };
+        state().notifications.push(item);
+        state().emit();
+        let timer;
+        const release = owner.own(() => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            const store = state();
+            const index = store.notifications.indexOf(item);
+            if (index >= 0) {
+                store.notifications.splice(index, 1);
+                store.emit();
+            }
+        });
+        if (item.timeoutMs > 0)
+            timer = setTimeout(release, item.timeoutMs);
+        return release;
+    };
+}

package/lib/types/dsh-adapter/channel/owner.d.ts

@@ -0,0 +1,18 @@
+/** Channel lifetime plus binding fences for work that crosses an await. */
+export declare function createChannelOwner(): {
+    current: () => boolean;
+    assertActive: () => void;
+    readonly cleanupCount: number;
+    signal: AbortSignal;
+    bind(check: () => boolean): void;
+    own(cleanup: () => void): () => void;
+    dispose(): void;
+};
+export type ChannelOwner = ReturnType<typeof createChannelOwner>;
+export declare function registerChannelOwner(channel: object, owner: ChannelOwner): void;
+export declare function bindChannelOwner(channel: object, check: () => boolean): void;
+export declare function channelOwnerCurrent(channel: object): boolean;
+/** Register work that must be revoked whenever this Channel owner releases. */
+export declare function onChannelOwnerDispose(channel: object, cleanup: () => void): () => void;
+export declare function disposeChannelOwner(channel: object): void;
+//# sourceMappingURL=owner.d.ts.map

package/lib/types/dsh-adapter/channel/owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/owner.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wBAAgB,kBAAkB;;;;;gBAgBlB,MAAM,OAAO;iBACZ,MAAM,IAAI;;EA0B1B;AACD,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAA+B;AAC/G,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,OAAO,GAAG,IAAI,CAAqC;AAClH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAmD;AAChH,+EAA+E;AAC/E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAGtF;AACD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAmC"}

package/lib/types/dsh-adapter/channel/owner.js

@@ -0,0 +1,73 @@
+/** Channel lifetime plus binding fences for work that crosses an await. */
+export function createChannelOwner() {
+    let active = true;
+    let externalCheck = () => true;
+    const cleanups = new Set();
+    const controller = new AbortController();
+    const current = () => {
+        if (!active)
+            return false;
+        try {
+            return externalCheck();
+        }
+        catch {
+            return false;
+        }
+    };
+    const assertActive = () => {
+        if (!current())
+            throw new Error('dsh-tui: Channel lifetime has ended');
+    };
+    return {
+        current, assertActive,
+        get cleanupCount() { return cleanups.size; },
+        signal: controller.signal,
+        bind(check) { externalCheck = check; },
+        own(cleanup) {
+            let released = false;
+            const release = () => {
+                if (released)
+                    return;
+                released = true;
+                cleanups.delete(release);
+                cleanup();
+            };
+            if (active)
+                cleanups.add(release);
+            else
+                release();
+            return release;
+        },
+        dispose() {
+            if (!active)
+                return;
+            active = false;
+            controller.abort();
+            const failures = [];
+            // Every registered resource gets one cleanup attempt. A throwing
+            // external disposer must not strand later subscriptions or handles.
+            for (const cleanup of [...cleanups]) {
+                try {
+                    cleanup();
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, 'dsh-tui: Channel cleanup failed');
+        },
+    };
+}
+const owners = new WeakMap();
+export function registerChannelOwner(channel, owner) { owners.set(channel, owner); }
+export function bindChannelOwner(channel, check) { owners.get(channel)?.bind(check); }
+export function channelOwnerCurrent(channel) { return owners.get(channel)?.current() ?? false; }
+/** Register work that must be revoked whenever this Channel owner releases. */
+export function onChannelOwnerDispose(channel, cleanup) {
+    const owner = owners.get(channel);
+    return owner === undefined ? (() => undefined) : owner.own(cleanup);
+}
+export function disposeChannelOwner(channel) { owners.get(channel)?.dispose(); }

package/lib/types/dsh-adapter/channel/paths.d.ts

@@ -0,0 +1,31 @@
+import { type FileCandidate } from '../../utils/fileSuggestions.js';
+import type { FileSuggestionFs } from './types.js';
+/** Trailing path segment (`C:/a/b` → `b`). */
+export declare function basename(path: string): string;
+/** Normalize a cwd for comparison: forward slashes, no trailing slash; case
+ *  folded when the platform's filesystem semantics are case-insensitive. */
+export declare function normalizeCwd(path: string, caseInsensitive: boolean): string;
+/**
+ * `/resume` project filter (issue #96): exact cwd match, PLUS sessions
+ * recorded in a subdirectory — pre-upgrade launches recorded the launch
+ * subdirectory as the header cwd, and with the cwd default now resolving to
+ * the git worktree root an exact match would hide those sessions forever.
+ * They belong to the same workspace, so they stay listed. Comparison follows
+ * the platform's filesystem semantics (case-insensitive on Windows — a
+ * pre-upgrade header may record `C:\Repo` where the current launch resolves
+ * `c:\repo`). `caseInsensitive` is a parameter (not a platform read) so the
+ * verifier can exercise both modes on any host. Exported for
+ * scripts/verify-session-cwd.mjs.
+ *
+ * Boundary rule (issue #153): container directories are nobody's workspace.
+ * $HOME and the Windows root forms — plain drive roots (`C:`), UNC share
+ * roots (`//server/share`), and extended-length roots (`//?/C:`,
+ * `//?/UNC/server/share`) — are ancestors of unrelated projects, so the
+ * descendant rules below would list every session on the machine from `~`
+ * (and every session on the drive/share from those roots). At these
+ * boundaries, in either direction, only an exact match passes.
+ */
+export declare function sessionCwdMatches(stateCwd: string, headerCwd: string, caseInsensitive?: boolean): boolean;
+export declare function listPathCandidates(fs: FileSuggestionFs, cwd: string, query: string, signal: AbortSignal | undefined, topK: number): Promise<FileCandidate[]>;
+export declare function listFilesDeepCandidates(fs: FileSuggestionFs | undefined, root: string, signal?: AbortSignal): Promise<FileCandidate[]>;
+//# sourceMappingURL=paths.d.ts.map

package/lib/types/dsh-adapter/channel/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/paths.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAEvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,8CAA8C;AAC9C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;4EAC4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,MAAM,CAG3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,eAAe,GAAE,OAAsC,GACtD,OAAO,CAwBT;AAED,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAyBlK;AAED,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,gBAAgB,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAmD5I"}

package/lib/types/dsh-adapter/channel/paths.js

@@ -0,0 +1,147 @@
+import { join } from 'node:path';
+import { rankFileCandidates } from '../../utils/fileSuggestions.js';
+import { homeDir } from '../../utils/paths.js';
+/** Trailing path segment (`C:/a/b` → `b`). */
+export function basename(path) {
+    const parts = path.split(/[\\/]/);
+    return parts[parts.length - 1] ?? path;
+}
+/** Normalize a cwd for comparison: forward slashes, no trailing slash; case
+ *  folded when the platform's filesystem semantics are case-insensitive. */
+export function normalizeCwd(path, caseInsensitive) {
+    const normalized = path.replace(/\\/g, '/').replace(/\/+$/, '');
+    return caseInsensitive ? normalized.toLowerCase() : normalized;
+}
+/**
+ * `/resume` project filter (issue #96): exact cwd match, PLUS sessions
+ * recorded in a subdirectory — pre-upgrade launches recorded the launch
+ * subdirectory as the header cwd, and with the cwd default now resolving to
+ * the git worktree root an exact match would hide those sessions forever.
+ * They belong to the same workspace, so they stay listed. Comparison follows
+ * the platform's filesystem semantics (case-insensitive on Windows — a
+ * pre-upgrade header may record `C:\Repo` where the current launch resolves
+ * `c:\repo`). `caseInsensitive` is a parameter (not a platform read) so the
+ * verifier can exercise both modes on any host. Exported for
+ * scripts/verify-session-cwd.mjs.
+ *
+ * Boundary rule (issue #153): container directories are nobody's workspace.
+ * $HOME and the Windows root forms — plain drive roots (`C:`), UNC share
+ * roots (`//server/share`), and extended-length roots (`//?/C:`,
+ * `//?/UNC/server/share`) — are ancestors of unrelated projects, so the
+ * descendant rules below would list every session on the machine from `~`
+ * (and every session on the drive/share from those roots). At these
+ * boundaries, in either direction, only an exact match passes.
+ */
+export function sessionCwdMatches(stateCwd, headerCwd, caseInsensitive = process.platform === 'win32') {
+    const cwd = normalizeCwd(stateCwd, caseInsensitive);
+    const recorded = normalizeCwd(headerCwd, caseInsensitive);
+    if (recorded === '' || cwd === '')
+        return false;
+    const home = normalizeCwd(homeDir(), caseInsensitive);
+    // Paths below arrive backslash-normalized (`\\server\share` →
+    // `//server/share`, `\\?\C:\` → `//?/C:`), trailing slashes stripped.
+    const isContainer = (path) => (home !== '' && path === home) ||
+        /^[a-z]:$/i.test(path) || // drive root: C:
+        /^\/\/[^/]+\/[^/]+$/.test(path) || // UNC share root: //server/share
+        /^\/\/\?\/[a-z]:$/i.test(path) || // extended drive root: //?/C:
+        /^\/\/\?\/unc\/[^/]+\/[^/]+$/i.test(path); // extended UNC root: //?/UNC/server/share
+    if (isContainer(cwd) || isContainer(recorded))
+        return recorded === cwd;
+    return (recorded === cwd ||
+        // Pre-upgrade subdirectory session of this workspace.
+        recorded.startsWith(`${cwd}/`) ||
+        // Resumed INTO a pre-upgrade subdirectory session (state.cwd adopted its
+        // recorded subdirectory): the workspace-root sessions it belongs with
+        // must stay visible, or /resume looks like it lost them for the rest of
+        // the process lifetime (review leftover).
+        cwd.startsWith(`${recorded}/`));
+}
+export async function listPathCandidates(fs, cwd, query, signal, topK) {
+    const normalized = query.replaceAll('\\', '/');
+    const slash = normalized.lastIndexOf('/');
+    // `.` / `..` without a trailing separator are whole-directory queries too.
+    const bareDir = slash < 0 && (normalized === '.' || normalized === '..' || normalized === '~');
+    const directoryPart = slash < 0 ? (bareDir ? `${normalized}/` : '') : normalized.slice(0, slash + 1);
+    const nameQuery = slash < 0 || bareDir ? '' : normalized.slice(slash + 1);
+    // `~/` expands against the host home (matches the cwd resolution rules);
+    // drive-letter and POSIX-absolute prefixes pass through untouched.
+    const expanded = directoryPart === '~/'
+        ? `${homeDir()}/`
+        : directoryPart.startsWith('/') || /^[A-Za-z]:\//.test(directoryPart)
+            ? directoryPart
+            : join(cwd, directoryPart || '.');
+    try {
+        if (signal?.aborted)
+            return [];
+        const target = await fs.resolve(expanded);
+        const entries = (await fs.listDir(target)).slice().sort((a, b) => a.name.localeCompare(b.name));
+        return rankFileCandidates(entries.filter(entry => entry.type === 'file' || entry.type === 'directory').map(entry => {
+            const path = `${directoryPart}${entry.name}${entry.type === 'directory' ? '/' : ''}`;
+            return { id: path, path, displayPath: path, name: entry.name, kind: entry.type, score: 0 };
+        }), nameQuery, topK);
+    }
+    catch {
+        return [];
+    }
+}
+export async function listFilesDeepCandidates(fs, root, signal) {
+    if (!fs)
+        return [];
+    const out = [];
+    const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', '.DS_Store', 'dist']);
+    const BUILD_DIR = /^(?:build(?:[-_].*)?|cmake-build(?:[-_].*)?)$/i;
+    const queue = [{ dir: root, prefix: '', index: 0 }];
+    const visited = new Set();
+    const maxFiles = 100;
+    const maxDirectories = 100;
+    let fileCount = 0;
+    let dirCount = 0;
+    // Round-robin: each directory yields ONE non-skipped entry per visit before
+    // it re-queues, so a large early sibling (e.g. `generated/` with 120 files)
+    // cannot starve `src/` out of the per-kind budgets. This is the regression
+    // contract pinned by scripts/verify-file-completion.mjs.
+    while (queue.length && fileCount < maxFiles && dirCount < maxDirectories) {
+        if (signal?.aborted)
+            return [];
+        const current = queue.shift();
+        if (!current.entries) {
+            try {
+                const target = await fs.resolve(current.dir);
+                if (visited.has(target.displayPath))
+                    continue;
+                visited.add(target.displayPath);
+                current.entries = (await fs.listDir(target)).slice().sort((a, b) => a.name.localeCompare(b.name));
+            }
+            catch {
+                continue;
+            }
+        }
+        let entry;
+        while (current.index < current.entries.length) {
+            const candidate = current.entries[current.index++];
+            if (SKIP.has(candidate.name) || BUILD_DIR.test(candidate.name))
+                continue;
+            entry = candidate;
+            break;
+        }
+        if (!entry)
+            continue;
+        if (current.index < current.entries.length)
+            queue.push(current);
+        const path = current.prefix ? `${current.prefix}/${entry.name}` : entry.name;
+        if (entry.type === 'directory') {
+            if (dirCount >= maxDirectories)
+                continue;
+            out.push({ id: `${path}/`, path: `${path}/`, displayPath: `${path}/`, name: entry.name, kind: 'directory', score: 0 });
+            dirCount += 1;
+            queue.push({ dir: entry.target?.displayPath ?? join(current.dir, entry.name), prefix: path, index: 0 });
+        }
+        else if (entry.type === 'file') {
+            if (fileCount >= maxFiles)
+                continue;
+            out.push({ id: path, path, displayPath: path, name: entry.name, kind: 'file', score: 0 });
+            fileCount += 1;
+        }
+    }
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}

package/lib/types/dsh-adapter/channel/permissions.d.ts

@@ -0,0 +1,40 @@
+import { type SessionModeSpec } from '../../sessionModes.js';
+import type { PermissionPresetOption, PermissionPresetService, PermissionPresetSnapshot } from './types.js';
+export declare const PERMISSION_PRESET_CUSTOM = "custom";
+export declare const PERMISSION_PRESET_NAME_CELLS = 120;
+export declare const PERMISSION_PRESET_DESCRIPTION_CELLS = 400;
+/** The mounted registry may expose seams this package's declared contract
+ *  does not name yet: `resolve` (atom bundles) and `set` (the write path the
+ *  official `/permission` command drives). Read structurally, never assumed. */
+export interface PermissionPresetRuntime extends PermissionPresetService {
+    resolve?: (name: string) => unknown;
+    set?: (subject: unknown, name: string) => unknown;
+}
+/** One runtime preset's resolved atom bundle. */
+export interface PermissionPresetBundle {
+    readonly value: string;
+    readonly sandbox?: SessionModeSpec['sandbox'];
+    readonly approval?: SessionModeSpec['approval'];
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Narrow a raw service read to the structural registry surface. */
+export declare function permissionPresetRuntime(service: unknown): PermissionPresetRuntime | undefined;
+/** Keep a permission roster read-only after it crosses the adapter boundary.
+ *  The registry may reuse and mutate its option objects between reads; callers
+ *  must observe one stable snapshot instead of a live view into that service. */
+export declare function freezePermissionPresetSnapshot(snapshot: PermissionPresetSnapshot): PermissionPresetSnapshot;
+export declare function legacyPermissionPresetOptions(): readonly PermissionPresetOption[];
+export declare function legacyPermissionPresetSnapshot(sandbox: SessionModeSpec['sandbox']): PermissionPresetSnapshot;
+export declare function unavailablePermissionPresetSnapshot(): PermissionPresetSnapshot;
+export declare function normalizePermissionPresetOption(value: unknown): PermissionPresetOption | undefined;
+/** Atom bundles the deployment's preset table resolves (value →
+ *  sandbox/approval). Empty when the service is absent or exposes no
+ *  `resolve` seam — canonical resolution then falls back to the stock
+ *  bundles (see `canonicalPresetFor`). */
+export declare function permissionBundlesFromService(service: unknown): readonly PermissionPresetBundle[];
+/** The registry's current readback for one subject. Real harness registries
+ *  resolve `current(session)` through their session-projections seam; earlier
+ *  contract versions folded a raw event log. Try the subject as given, then
+ *  the event-log shape it may carry. */
+export declare function permissionPresetSnapshotFromService(service: unknown, subject: unknown): PermissionPresetSnapshot;
+//# sourceMappingURL=permissions.d.ts.map

package/lib/types/dsh-adapter/channel/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/permissions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE3G,eAAO,MAAM,wBAAwB,WAAW,CAAA;AAEhD,eAAO,MAAM,4BAA4B,MAAM,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;gFAEgF;AAChF,MAAM,WAAW,uBAAwB,SAAQ,uBAAuB;IACtE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IACnC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAClD;AAED,iDAAiD;AACjD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAC,UAAU,CAAC,CAAA;CAChD;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,oEAAoE;AACpE,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,uBAAuB,GAAG,SAAS,CAE7F;AAED;;iFAEiF;AACjF,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,wBAAwB,GAAG,wBAAwB,CAQ3G;AAED,wBAAgB,6BAA6B,IAAI,SAAS,sBAAsB,EAAE,CAkBjF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,wBAAwB,CAU5G;AAED,wBAAgB,mCAAmC,IAAI,wBAAwB,CAE9E;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,GAAG,SAAS,CAclG;AAED;;;0CAG0C;AAC1C,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,sBAAsB,EAAE,CAwBhG;AAED;;;wCAGwC;AACxC,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,GACf,wBAAwB,CAyE1B"}