@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

package/lib/types/adapter/kernel/replay.js

@@ -0,0 +1,425 @@
+/**
+ * Passive / Replay shadow harness (P2 minimal).
+ *
+ * - Passive Shadow: `KernelRuntime.detect()` + `descriptorBuild()` already
+ *   produce a read-only diagnostic snapshot without registering, subscribing,
+ *   or writing. This module does not add a second passive path.
+ * - Replay Shadow: this module defines a JSON-friendly replay input and a real
+ *   runnable path that feeds isolated mock upstream services into the same
+ *   KernelRuntime/driver used by production. It never connects to a real DSH
+ *   host and never writes real plugin state.
+ *
+ * The replay input is intentionally small and line-protocol-free. It records
+ * the minimal host facts needed to exercise the new driver: command catalog,
+ * service availability, and DecisionEvents vocabulary.
+ */
+import { KernelRuntime } from './kernel-runtime.js';
+import { hostDescriptorDriver } from '../upstream/host-descriptor-driver.js';
+import { registerCommandLiveProbe, registerMessageLiveProbe, registerStorageLiveProbe, } from './host-probe-access.js';
+import { withReplayIsolation } from './replay-isolation.js';
+import { createReplayChannelProvider, createChannelConsumer, } from '../channel/index.js';
+import { TUI_CHANNEL_FEATURES, TUI_CHANNEL_WIRE_REVISION, } from '../standard/tui-extension.js';
+import { validateTuiChannelRequirement, validateTuiChannelSupport, } from '../spec/index.js';
+import { projectDshSessionEventsToSnapshots, } from '../channel/session-projection.js';
+export const REPLAY_SCHEMA_VERSION = 'tui-adapter-replay/v1';
+export const REPLAY_CHANNEL_SCHEMA_VERSION = 'tui-adapter-channel-replay/v1';
+/**
+ * Replay method → feature mapping used by the conformance harness.
+ *
+ * The DSH Channel RFC requires `invoke.method` to correspond to a feature
+ * the provider declared. This is the harness-side recognized map for the live
+ * channel methods; unknown method names are rejected instead of pretending
+ * success.
+ */
+export const CHANNEL_METHOD_FEATURES = Object.freeze({
+    commandCompletions: 'commands',
+    runExternalCommand: 'commands',
+    runWorkspaceCommand: 'workspaces',
+    listWorkspaces: 'workspaces',
+    resolveWorkspace: 'workspaces',
+    switchWorkspace: 'workspaces',
+    workspaceCommands: 'workspaces',
+    listModels: 'models',
+    switchModel: 'models',
+    listEfforts: 'models',
+    setEffort: 'models',
+    listProviders: 'provider-setup',
+    providerSetup: 'provider-setup',
+    describeCredential: 'credentials',
+    oauthProviderStatuses: 'credentials',
+    listPresets: 'presets',
+    switchPreset: 'presets',
+    listSkills: 'skills',
+    listSessions: 'session-history',
+    previewSession: 'session-history',
+    deleteSession: 'session-history',
+    renameSession: 'session-history',
+    forkSession: 'session-history',
+    resumeTo: 'session-history',
+    newSession: 'session-lifecycle',
+    compact: 'session-lifecycle',
+    submit: 'session-input',
+    steer: 'session-input',
+    cancel: 'session-input',
+    interruptAndDeliver: 'session-input',
+    clear: 'session-input',
+    loadOlder: 'session-input',
+    rewindTo: 'session-input',
+    promptRewind: 'session-input',
+    openPluginScene: 'scenes',
+    closePluginScene: 'scenes',
+    settingsSections: 'settings',
+    subscribeSettingsSections: 'settings',
+    traceEvents: 'trace',
+    notify: 'presentation',
+    doctorInfo: 'diagnostics',
+    mcpStatus: 'diagnostics',
+    pluginsInfo: 'diagnostics',
+    listFileCandidates: 'files',
+    listFiles: 'files',
+    listSubagents: 'subagents',
+    balanceInfo: 'credentials',
+});
+/**
+ * Per-feature state evidence keys.
+ *
+ * A declared Channel feature must be backed by an observable state field or
+ * a declared method handler; otherwise the replay is only an empty protocol
+ * envelope and must not be reported `ok`.
+ */
+const CHANNEL_FEATURE_STATE_EVIDENCE_KEYS = Object.freeze({
+    'session-state': ['status', 'sessionTitle', 'homeDir', 'pathCaseInsensitive', 'model', 'mode', 'agentId'],
+    'session-input': ['transcript', 'pending', 'lastUserText'],
+    'commands': ['commandCatalog'],
+    'models': ['model'],
+    'modes': ['mode'],
+    'presets': ['agentPreset'],
+    'presentation': ['notification', 'toast'],
+    'provider-setup': ['provider'],
+    'credentials': ['credential', 'credentials', 'oauthProviderStatuses'],
+    'diagnostics': ['diagnostic', 'diagnostics'],
+    'files': ['files', 'fileCandidates'],
+    'scenes': ['pluginScene', 'scene'],
+    'settings': ['settingsSections'],
+    'skills': ['skills'],
+    'subagents': ['subagents'],
+    'workspaces': ['workspace', 'workspaces'],
+    'session-history': ['sessions', 'sessionHistory'],
+    'session-lifecycle': ['sessionLifecycle'],
+    'trace': ['traceEvents', 'traceData'],
+});
+function hasMeaningfulEvidenceValue(value) {
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value !== null && typeof value === 'object')
+        return Object.keys(value).length > 0;
+    if (typeof value === 'string')
+        return value.trim() !== '';
+    return value !== undefined;
+}
+function featureHasEvidence(feature, snapshots, verifiedMethods) {
+    const state = snapshots.at(-1)?.state ?? {};
+    const keys = CHANNEL_FEATURE_STATE_EVIDENCE_KEYS[feature] ?? [];
+    for (const key of keys) {
+        if (hasMeaningfulEvidenceValue(state[key]))
+            return true;
+    }
+    // A declared method handler is NOT evidence by itself: the method must have
+    // been successfully invoked through `invokeMethod` during this replay.
+    return [...verifiedMethods].some(method => CHANNEL_METHOD_FEATURES[method] === feature);
+}
+export class ReplayHarnessError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReplayHarnessError';
+    }
+}
+/** Isolated host-context stub backed entirely by the replay input. */
+export function createReplayContext(input) {
+    const commandRegistry = new Map();
+    const commands = Object.freeze({
+        register(definition) {
+            if (commandRegistry.has(definition.name)) {
+                throw new Error(`replay command already registered: ${definition.name}`);
+            }
+            commandRegistry.set(definition.name, {
+                name: definition.name,
+                description: definition.description,
+                handler: definition.handler,
+            });
+            return () => {
+                commandRegistry.delete(definition.name);
+            };
+        },
+        list() {
+            return Object.freeze([...commandRegistry.values()].map(command => Object.freeze({
+                name: command.name,
+                description: command.description,
+            })));
+        },
+        find(_agent, name) {
+            return commandRegistry.get(name);
+        },
+        async execute(_agent, line, _images, signal) {
+            const match = /^\/([a-z][a-z0-9_-]*)(?=$|[\t\n\r ])/u.exec(line);
+            if (match === null)
+                return undefined;
+            const command = commandRegistry.get(match[1]);
+            if (command === undefined)
+                return undefined;
+            if (signal.aborted)
+                throw new Error('replay command aborted');
+            const result = await command.handler();
+            if (result === null || typeof result !== 'object' || result.kind !== 'success') {
+                throw new Error('replay command handler did not return success');
+            }
+            return { commandId: 'replay', result: result };
+        },
+    });
+    const storage = Object.freeze({
+        open: () => Object.freeze({}),
+        probeDiagnostic: () => Object.freeze({ service: 'tuiPluginStorage', ok: true, dir: 'replay' }),
+    });
+    registerStorageLiveProbe(storage, async () => Object.freeze({
+        service: 'tuiPluginStorage',
+        ok: true,
+        operations: Object.freeze(['write', 'read', 'delete']),
+        tempNamespace: 'replay-temp',
+    }));
+    const messages = Object.freeze({
+        subscribe: () => () => undefined,
+        probeDiagnostic: () => Object.freeze({ service: 'tuiMessageObserver', ok: true, subscriptions: 0 }),
+    });
+    registerMessageLiveProbe(messages, async () => Object.freeze({
+        service: 'tuiMessageObserver',
+        ok: true,
+        before: 0,
+        during: 1,
+        after: 0,
+        delivered: 1,
+    }));
+    const host = Object.freeze({
+        hostDescriptor: () => Object.freeze({ descriptor: Object.freeze({ contracts: [] }), dropped: [], warnings: [] }),
+        describe: () => Object.freeze({ descriptor: Object.freeze({ contracts: [] }), dropped: [], warnings: [] }),
+        subscribeDecision: () => () => undefined,
+        probeDecisionEvents: () => Object.freeze([...(input.decisionEvents ?? [])]),
+    });
+    registerCommandLiveProbe(host, async () => Object.freeze({
+        ok: true,
+        name: 'replay-command-probe',
+        lifecycleAppends: 0,
+    }));
+    return Object.freeze({
+        get(name) {
+            switch (name) {
+                case 'commands': return input.commands === undefined ? undefined : commands;
+                case 'tuiPluginStorage': return input.storage === true ? storage : undefined;
+                case 'tuiMessageObserver': return input.messages === true ? messages : undefined;
+                case 'tuiPluginHost': return host;
+                default: return undefined;
+            }
+        },
+    });
+}
+/**
+ * Run a real DSH session snapshot/transcript Channel replay through the
+ * protocol Provider/Consumer pair.
+ *
+ * This path validates the full `tui.dsh/v1alpha1#Channel` envelope:
+ * - `open` returns a validated complete snapshot;
+ * - `subscribe` streams every recorded snapshot (> afterVersion) in order;
+ * - `invoke` accepts JSON arguments, returns a JSON result and always
+ *   includes the latest validated snapshot;
+ * - `close` acknowledges closure;
+ * - monotonic version/wire-revision continuity is checked by the consumer.
+ */
+export async function runChannelReplay(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new ReplayHarnessError('channel replay input must be an object');
+    }
+    const hasSessionEvents = Array.isArray(input.sessionEvents);
+    const snapshots = input.snapshots ?? (hasSessionEvents
+        ? projectDshSessionEventsToSnapshots(input.sessionEvents, input.sessionMeta ?? {
+            channelId: 'dsh-session-replay',
+        })
+        : []);
+    if (!Array.isArray(snapshots) || snapshots.length === 0) {
+        throw new ReplayHarnessError('channel replay input must contain snapshots or DSH sessionEvents');
+    }
+    const source = input.snapshots !== undefined ? 'snapshots' : 'dsh-session-events';
+    return await withReplayIsolation(async () => {
+        const replaySource = { ...input, snapshots };
+        const provider = createReplayChannelProvider(replaySource);
+        const versions = [];
+        const subscriptionSnapshots = [];
+        const subscriptionConsumer = createChannelConsumer(provider, { failClosed: false });
+        const first = snapshots[0];
+        // Subscribe first on an independent consumer so version continuity is
+        // observed over the recorded stream without conflating it with `open`
+        // returning the latest current snapshot.
+        await subscriptionConsumer.subscribe(first.channelId, 0, snapshot => {
+            subscriptionSnapshots.push(snapshot);
+            versions.push(snapshot.version);
+        });
+        const featureErrors = [];
+        const rawFeatures = input.features;
+        if (rawFeatures === undefined) {
+            featureErrors.push('features must be explicitly declared by the replay input');
+        }
+        const seenFeatures = new Set();
+        for (const feature of rawFeatures ?? []) {
+            if (seenFeatures.has(feature)) {
+                featureErrors.push(`duplicate Channel feature: ${feature}`);
+            }
+            seenFeatures.add(feature);
+        }
+        const features = [...new Set(rawFeatures ?? [])];
+        const allowedFeatures = new Set(TUI_CHANNEL_FEATURES);
+        for (const feature of features) {
+            if (!allowedFeatures.has(feature))
+                featureErrors.push(`unknown Channel feature: ${feature}`);
+        }
+        try {
+            validateTuiChannelRequirement({ wireRevision: TUI_CHANNEL_WIRE_REVISION, features });
+            validateTuiChannelSupport({ wireRevision: TUI_CHANNEL_WIRE_REVISION, features });
+        }
+        catch (error) {
+            featureErrors.push(error instanceof Error ? error.message : String(error));
+        }
+        const verifiedMethods = new Set();
+        const methodErrors = [];
+        for (const [method, feature] of Object.entries(CHANNEL_METHOD_FEATURES)) {
+            if (input.methods?.[method] === undefined)
+                continue;
+            if (!features.includes(feature)) {
+                methodErrors.push(`method ${method} requires feature ${feature}, which is not declared`);
+            }
+        }
+        if (input.methods !== undefined) {
+            for (const method of Object.keys(input.methods)) {
+                if (CHANNEL_METHOD_FEATURES[method] === undefined) {
+                    methodErrors.push(`method ${method} is not in the recognized method->feature map`);
+                }
+            }
+        }
+        const consumer = createChannelConsumer(provider, { failClosed: false });
+        const opened = await consumer.open({});
+        let invokeValueDefined = false;
+        if (input.invokeMethod !== undefined) {
+            if (input.methods?.[input.invokeMethod] === undefined) {
+                methodErrors.push(`invokeMethod ${input.invokeMethod} is not provided by replay methods`);
+            }
+            else {
+                try {
+                    const invoke = await consumer.invoke(opened.channelId, input.invokeMethod, []);
+                    invokeValueDefined = invoke.valueDefined === true;
+                    // Only a method that actually executed successfully can back a
+                    // method-backed feature claim.
+                    verifiedMethods.add(input.invokeMethod);
+                }
+                catch (error) {
+                    methodErrors.push(error instanceof Error ? error.message : String(error));
+                }
+            }
+        }
+        for (const feature of features) {
+            if (!featureHasEvidence(feature, snapshots, verifiedMethods)) {
+                featureErrors.push(`Channel feature ${feature} has no observable evidence in state or successfully invoked methods`);
+            }
+        }
+        const closed = await consumer.close(opened.channelId);
+        const continuityErrors = [
+            ...subscriptionConsumer.continuityErrors(),
+            ...consumer.continuityErrors(),
+        ];
+        const ok = continuityErrors.length === 0
+            && featureErrors.length === 0
+            && methodErrors.length === 0
+            && opened.wireRevision === TUI_CHANNEL_WIRE_REVISION
+            && opened.channelId === first.channelId
+            && closed.closed === true;
+        return Object.freeze({
+            ok,
+            schemaVersion: REPLAY_CHANNEL_SCHEMA_VERSION,
+            channelId: opened.channelId,
+            wireRevision: opened.wireRevision,
+            versions: Object.freeze(versions),
+            features: Object.freeze(features),
+            transcriptCount: input.transcript?.length ?? 0,
+            continuityErrors: Object.freeze(continuityErrors),
+            openVersion: opened.version,
+            invokeValueDefined,
+            closed: closed.closed,
+            source,
+            sessionEventCount: input.sessionEvents?.length ?? 0,
+            featureErrors: Object.freeze(featureErrors),
+            methodErrors: Object.freeze(methodErrors),
+        });
+    });
+}
+/**
+ * Run an isolated replay-shadow comparison through the production KernelRuntime
+ * and host-descriptor driver.
+ *
+ * This is fail-closed: malformed replay input or an unavailable schema aborts
+ * with `ReplayHarnessError` rather than silently falling back to a legacy view.
+ */
+export async function runReplayShadow(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new ReplayHarnessError('replay input must be an object');
+    }
+    if (input.schemaVersion !== REPLAY_SCHEMA_VERSION) {
+        throw new ReplayHarnessError(`unsupported replay schema ${String(input.schemaVersion)}; expected ${REPLAY_SCHEMA_VERSION}`);
+    }
+    const generationId = input.generationId ?? 'replay-shadow';
+    const context = createReplayContext(input);
+    return await withReplayIsolation(async () => {
+        const kernel = new KernelRuntime({
+            context,
+            mode: 'replay-shadow',
+            generationId,
+            hostId: input.host?.id,
+            hostVersion: input.host?.version,
+            drivers: [hostDescriptorDriver],
+        });
+        try {
+            await kernel.refresh({ allowReplay: true });
+            const build = kernel.descriptorBuild();
+            const kernelContracts = build.descriptor.contracts.map(contract => `${contract.apiVersion}#${contract.kind}`).sort();
+            const legacyContracts = [...(input.host?.legacyContracts ?? [])]
+                .map(contract => `${contract.apiVersion}#${contract.kind}`)
+                .sort();
+            const kernelSet = new Set(kernelContracts);
+            const legacySet = new Set(legacyContracts);
+            const matched = kernelContracts.filter(key => legacySet.has(key));
+            const missing = legacyContracts.filter(key => !kernelSet.has(key));
+            const extra = kernelContracts.filter(key => !legacySet.has(key));
+            const channel = input.channel === undefined
+                ? undefined
+                : await runChannelReplay(input.channel);
+            return Object.freeze({
+                ok: missing.length === 0 && extra.length === 0 && (channel?.ok ?? true),
+                schemaVersion: REPLAY_SCHEMA_VERSION,
+                generationId,
+                mode: 'replay-shadow',
+                kernelContracts: Object.freeze(kernelContracts),
+                legacyContracts: Object.freeze(legacyContracts),
+                missing: Object.freeze(missing),
+                extra: Object.freeze(extra),
+                matched: Object.freeze(matched),
+                lifecycles: kernel.currentLifecycles(),
+                dropped: Object.freeze([...build.dropped]),
+                warnings: Object.freeze([...build.warnings]),
+                ...(channel === undefined ? {} : { channel }),
+            });
+        }
+        finally {
+            kernel.dispose();
+        }
+    });
+}
+/** Convenience for the production fail-closed check: a real host cannot run
+ * replay-shadow without an explicit isolated replay input. */
+export function assertReplayShadowProductionUnavailable() {
+    throw new ReplayHarnessError('replay-shadow on a real production host is not available without an isolated replay input; use scripts/verify-adapter-replay-harness.ts or the replay module');
+}

package/lib/types/adapter/kernel/runtime-context.d.ts

@@ -0,0 +1,15 @@
+/** Immutable adapter runtime snapshot bound to one Cordis composition. */
+import { compositionRoot } from '../../dsh-adapter/host-access.js';
+import { type AdapterRuntimeOptions } from './runtime.js';
+type AdapterContext = Parameters<typeof compositionRoot>[0];
+/**
+ * Capture adapter mode and slice selection once for a composition. Runtime
+ * policy must not be re-read from process.env by individual services: doing
+ * so lets an in-process caller change shadow policy after mount.
+ */
+export declare function adapterRuntimeFor(ctx: AdapterContext): AdapterRuntimeOptions;
+/** Test/embedding hook: explicit env input remains available without making
+ * production services depend on mutable process state after construction. */
+export declare function snapshotAdapterRuntime(env: NodeJS.ProcessEnv): AdapterRuntimeOptions;
+export {};
+//# sourceMappingURL=runtime-context.d.ts.map

package/lib/types/adapter/kernel/runtime-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-context.d.ts","sourceRoot":"","sources":["../../../../src/adapter/kernel/runtime-context.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAE1E,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAClE,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,cAAc,CAAA;AAErB,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;AAI3D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,qBAAqB,CAQ5E;AAED;6EAC6E;AAC7E,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,qBAAqB,CAEpF"}

package/lib/types/adapter/kernel/runtime-context.js

@@ -0,0 +1,24 @@
+/** Immutable adapter runtime snapshot bound to one Cordis composition. */
+import { compositionRoot } from '../../dsh-adapter/host-access.js';
+import { parseAdapterRuntime, } from './runtime.js';
+const snapshots = new WeakMap();
+/**
+ * Capture adapter mode and slice selection once for a composition. Runtime
+ * policy must not be re-read from process.env by individual services: doing
+ * so lets an in-process caller change shadow policy after mount.
+ */
+export function adapterRuntimeFor(ctx) {
+    const root = compositionRoot(ctx);
+    const key = root;
+    const existing = snapshots.get(key);
+    if (existing !== undefined)
+        return existing;
+    const snapshot = parseAdapterRuntime();
+    snapshots.set(key, snapshot);
+    return snapshot;
+}
+/** Test/embedding hook: explicit env input remains available without making
+ * production services depend on mutable process state after construction. */
+export function snapshotAdapterRuntime(env) {
+    return parseAdapterRuntime(env);
+}

package/lib/types/adapter/kernel/runtime.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Adapter runtime / shadow-mode switch and effect-class enforcement.
+ *
+ * This is the Kernel's incremental-migration control surface. It does not load
+ * drivers or perform business translation; it selects and records shadow
+ * policy per capability, and provides the unified assertion every
+ * effect-producing Port/slice entry must call.
+ */
+import type { HostEffectClass } from '../ports/owner.js';
+export type AdapterMode = 'legacy' | 'passive-shadow' | 'replay-shadow' | 'new';
+export type AdapterSliceName = string;
+export interface AdapterRuntimeOptions {
+    readonly mode: AdapterMode;
+    readonly slices: readonly AdapterSliceName[];
+}
+export declare const DEFAULT_ADAPTER_MODE: AdapterMode;
+/**
+ * Effect classification per adapter capability.
+ *
+ * Every capability that can produce an effect must be registered here so the
+ * runtime can enforce shadow policy uniformly instead of relying on ad-hoc
+ * call-site checks.
+ */
+export declare const ADAPTER_CAPABILITY_EFFECT_CLASSES: Readonly<Record<string, HostEffectClass>>;
+/** Map a capability to its incremental migration slice. */
+export declare const ADAPTER_CAPABILITY_SLICES: Readonly<Record<string, string>>;
+export declare function sliceForCapability(capability: string): string | undefined;
+export declare function effectClassFor(capability: string): HostEffectClass | undefined;
+export declare function parseAdapterMode(value: string | undefined): AdapterMode;
+export declare const ADAPTER_SLICE_ALIASES: Readonly<Record<string, string>>;
+/**
+ * Normalize an explicit adapter-slice allowlist.
+ *
+ * Slice ids are case-insensitive and surrounding whitespace is ignored.
+ * Known aliases are mapped to their canonical slice id. Unknown ids are
+ * rejected loudly (fail-closed) instead of being silently ignored: a typo in
+ * `DSH_TUI_ADAPTER_SLICES` must never accidentally broaden or narrow the
+ * governed adapter surface without the operator noticing.
+ */
+export declare function normalizeAdapterSliceList(slices: readonly string[]): readonly string[];
+export declare function parseAdapterRuntime(env?: NodeJS.ProcessEnv): AdapterRuntimeOptions;
+/**
+ * Immutable fallback snapshot factory for objects that are not bound to a
+ * Cordis composition (standalone stores, in-package local registries, unbound
+ * grant stores). Each object captures the process environment at construction
+ * time; once captured, that object never re-reads mutable process state.
+ * Production composition-bound services must use `adapterRuntimeFor(ctx)`
+ * instead so each composition root gets its own stable snapshot.
+ */
+export declare function defaultAdapterRuntime(): AdapterRuntimeOptions;
+/**
+ * Effect classification determines which shadow modes are allowed:
+ * - read-only may run as passive shadow and replay shadow;
+ * - subscribe/register require replay or direct switch;
+ * - mutate only runs in legacy/new (it must never pretend to be a shadow).
+ */
+export declare function isPassiveShadowAllowed(effectClass: HostEffectClass): boolean;
+export declare function shadowPolicyAllowed(effectClass: HostEffectClass, mode: AdapterMode): boolean;
+export declare function assertShadowPolicy(effectClass: HostEffectClass, mode: AdapterMode): void;
+/**
+ * Hard guard-position invariant for adapter capability methods:
+ * every mediated/effectful entry MUST call this guard (or the
+ * `assertAdapterCapability` convenience) as its FIRST side-effect-free
+ * preflight step, BEFORE creating subscriptions, registrations, file watches,
+ * writes, mounts or any other observable side effect. This is also enforced
+ * by `verify:adapter-shadow` for service methods and returned handles.
+ */
+export declare function assertCapabilityShadowPolicy(capability: string, mode: AdapterMode, slices?: readonly string[]): void;
+export declare function assertAdapterCapability(capability: string): void;
+//# sourceMappingURL=runtime.d.ts.map

package/lib/types/adapter/kernel/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/adapter/kernel/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,gBAAgB,GAAG,eAAe,GAAG,KAAK,CAAA;AAC/E,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAA;AAErC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAC7C;AAED,eAAO,MAAM,oBAAoB,EAAE,WAAsB,CAAA;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAgFtF,CAAA;AAGF,2DAA2D;AAC3D,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA8ErE,CAAA;AAEF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEzE;AAaD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAE9E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAevE;AAED,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcjE,CAAA;AASF;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAatF;AAED,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,qBAAqB,CAK/F;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,qBAAqB,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,eAAe,GAAG,OAAO,CAE5E;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAW5F;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAMxF;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,WAAW,EACjB,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GACzB,IAAI,CAUN;AAOD,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAGhE"}