@chengxianglibra/dsh-data-analysis 0.1.1 → 0.1.2

package/lib/semantic-reference/bridge.js

@@ -0,0 +1,118 @@
+import { parseProjection } from "./contracts.js";
+export const CATALOG_PROGRAM = String.raw `
+import contextlib, io, json, sys
+with contextlib.redirect_stdout(io.StringIO()):
+    import marivo.semantic as ms
+    from marivo.refs import RefPayloadV1, SemanticKind
+    catalog = ms.load(workspace_dir=sys.argv[1])
+    rows = []
+    for kind in SemanticKind:
+        for entry in catalog.items(kind).items:
+            definition = entry.details().context.business_definition
+            rows.append({"ref": RefPayloadV1.from_ref(entry.ref).to_dict(), "refKey": entry.ref.key,
+                         "name": entry.name, "businessDefinition": definition[:240] if definition else None})
+    result = {"kinds": [kind.value for kind in SemanticKind], "items": rows}
+print(json.dumps(result, ensure_ascii=True))
+`.trim();
+/** One plugin-owned cache, keyed by the exact Environment fingerprint. */
+export class SemanticReferenceBridge {
+    #slots = new Map();
+    #clock;
+    #disposed = false;
+    constructor(clock = Date.now) {
+        this.#clock = clock;
+    }
+    async candidates(runner, signal) {
+        signal.throwIfAborted();
+        if (this.#disposed)
+            throw new Error('disposed');
+        const key = runner.binding.fingerprint;
+        if (runner.status !== 'ready') {
+            this.invalidate(key);
+            throw new Error('environment-failed');
+        }
+        let slot = this.#slots.get(key);
+        if (!slot) {
+            slot = {};
+            this.#slots.set(key, slot);
+        }
+        if (slot.snapshot && this.#clock() < slot.expires)
+            return slot.snapshot;
+        if (!slot.flight) {
+            const current = slot;
+            const controller = new AbortController();
+            const flight = {
+                controller,
+                waiters: 0,
+                promise: Promise.resolve({ kinds: [], items: [] }),
+            };
+            current.flight = flight;
+            flight.promise = this.#load(runner, controller.signal)
+                .then((projection) => {
+                if (!controller.signal.aborted &&
+                    !this.#disposed &&
+                    current.flight === flight &&
+                    runner.status === 'ready') {
+                    current.snapshot = projection;
+                    current.expires = this.#clock() + 30_000;
+                }
+                return projection;
+            })
+                .finally(() => {
+                if (current.flight === flight)
+                    current.flight = undefined;
+            });
+        }
+        const current = slot, flight = slot.flight;
+        flight.waiters++;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (value, error) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal.removeEventListener('abort', abort);
+                flight.controller.signal.removeEventListener('abort', loadAbort);
+                flight.waiters--;
+                if (!flight.waiters && current.flight === flight) {
+                    current.flight = undefined;
+                    flight.controller.abort();
+                }
+                if (error !== undefined)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            const abort = () => finish(undefined, new Error('cancelled'));
+            const loadAbort = () => finish(undefined, new Error('cancelled'));
+            signal.addEventListener('abort', abort, { once: true });
+            flight.controller.signal.addEventListener('abort', loadAbort, { once: true });
+            flight.promise.then((value) => finish(value), (error) => finish(undefined, error));
+            if (signal.aborted || flight.controller.signal.aborted)
+                abort();
+        });
+    }
+    async #load(runner, signal) {
+        const result = await runner.runChecked({
+            program: CATALOG_PROGRAM,
+            args: [runner.binding.projectRoot],
+            signal,
+            environmentOverlay: { MARIVO_TELEMETRY: 'off', PYTHONDONTWRITEBYTECODE: '1' },
+            limits: { timeoutMs: 30_000, stdoutMaxBytes: 32 * 1024 * 1024, stderrMaxBytes: 8192 },
+        });
+        signal.throwIfAborted();
+        if (result.exitCode !== 0)
+            throw new Error('catalog-load-failed');
+        return parseProjection(JSON.parse(result.stdout.toString('utf8')));
+    }
+    invalidate(key) {
+        const slot = this.#slots.get(key);
+        this.#slots.delete(key);
+        slot?.flight?.controller.abort();
+    }
+    dispose() {
+        this.#disposed = true;
+        for (const key of this.#slots.keys())
+            this.invalidate(key);
+    }
+}

package/lib/semantic-reference/contracts.js

@@ -0,0 +1,113 @@
+/** Browser-safe wire contracts. These bounds do not reimplement Marivo's domain grammar. */
+export const CHANNEL = '/dsh-data-analysis';
+export const SOURCE = 'marivo-semantic';
+export const LIMIT = 40;
+export const MAX_WIRE_BYTES = 1024 * 1024;
+export function closed(value, keys) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error('invalid-request');
+    const record = value;
+    if (Object.keys(record).length !== keys.length || keys.some((key) => !Object.hasOwn(record, key)))
+        throw new Error('invalid-request');
+    return record;
+}
+export function boundedText(value, max, empty = false) {
+    if (typeof value !== 'string' ||
+        value.length > max * 2 ||
+        (!empty && value.length === 0) ||
+        Array.from(value).length > max)
+        throw new Error('invalid-request');
+    return value;
+}
+export function parseJson(value, max = 16_384) {
+    const text = boundedText(value, max);
+    return JSON.parse(text);
+}
+export function parseRef(value) {
+    const r = closed(value, ['schema', 'kind', 'path']);
+    if (r.schema !== 'marivo.semantic_ref/v1')
+        throw new Error('invalid-request');
+    return Object.freeze({
+        schema: r.schema,
+        kind: boundedText(r.kind, 128),
+        path: boundedText(r.path, 2048),
+    });
+}
+export function refKey(ref) {
+    return `${ref.kind}:${ref.path}`;
+}
+export function parseEnvelope(value) {
+    const r = closed(value, ['schema', 'sessionId', 'environmentFingerprint', 'ref']);
+    if (r.schema !== 'dsh-data-analysis-semantic-reference/v1')
+        throw new Error('invalid-request');
+    return Object.freeze({
+        schema: r.schema,
+        sessionId: boundedText(r.sessionId, 256),
+        environmentFingerprint: boundedText(r.environmentFingerprint, 256),
+        ref: parseRef(r.ref),
+    });
+}
+export function envelopeJson(envelope) {
+    return JSON.stringify(parseEnvelope(envelope));
+}
+export function modelMarker(envelope) {
+    // Keep JSON inside one marker even when a valid domain path contains markup characters.
+    const json = JSON.stringify(parseRef(envelope.ref))
+        .replaceAll('<', '\\u003c')
+        .replaceAll('>', '\\u003e')
+        .replaceAll('&', '\\u0026');
+    return `<marivo-semantic-ref>${json}</marivo-semantic-ref>`;
+}
+export function parseCandidate(value) {
+    const r = closed(value, ['ref', 'refKey', 'name', 'businessDefinition']);
+    const ref = parseRef(r.ref);
+    if (r.refKey !== refKey(ref))
+        throw new Error('invalid-request');
+    return Object.freeze({
+        ref,
+        refKey: r.refKey,
+        name: boundedText(r.name, 2048),
+        businessDefinition: r.businessDefinition === null ? null : boundedText(r.businessDefinition, 240, true),
+    });
+}
+export function parseProjection(value) {
+    const r = closed(value, ['kinds', 'items']);
+    if (!Array.isArray(r.kinds) ||
+        r.kinds.length > 128 ||
+        !Array.isArray(r.items) ||
+        r.items.length > 100_000)
+        throw new Error('invalid-request');
+    const kinds = r.kinds.map((kind) => boundedText(kind, 128));
+    if (new Set(kinds).size !== kinds.length)
+        throw new Error('invalid-request');
+    const items = r.items.map(parseCandidate);
+    if (new Set(items.map((item) => item.refKey)).size !== items.length ||
+        items.some((item) => !kinds.includes(item.ref.kind)))
+        throw new Error('invalid-request');
+    return Object.freeze({ kinds: Object.freeze(kinds), items: Object.freeze(items) });
+}
+export function parseCandidatesRequest(value) {
+    const r = closed(value, ['version', 'sessionId', 'query', 'quoted', 'limit']);
+    if (r.version !== 1 || r.limit !== LIMIT || typeof r.quoted !== 'boolean')
+        throw new Error('invalid-request');
+    return {
+        version: 1,
+        sessionId: boundedText(r.sessionId, 256),
+        query: boundedText(r.query, 128, true),
+        quoted: r.quoted,
+        limit: LIMIT,
+    };
+}
+export function parseCandidatesResponse(value) {
+    const r = closed(value, ['environmentFingerprint', 'items']);
+    if (!Array.isArray(r.items) || r.items.length > LIMIT)
+        throw new Error('invalid-response');
+    const items = r.items.map((raw) => {
+        const item = closed(raw, ['ref', 'refKey', 'name', 'businessDefinition', 'section']);
+        const { section, ...candidate } = item;
+        if (section !== 'recent' && section !== 'kind' && section !== 'strict' && section !== 'fuzzy')
+            throw new Error('invalid-response');
+        return { ...parseCandidate(candidate), section };
+    });
+    return { environmentFingerprint: boundedText(r.environmentFingerprint, 256), items };
+}

package/lib/semantic-reference/index.js

@@ -0,0 +1,3 @@
+export { SemanticReferenceBridge } from "./bridge.js";
+export { registerSemanticReferenceRpc, SemanticReferenceService } from "./rpc.js";
+export { SemanticReferenceUsage } from "./usage.js";

package/lib/semantic-reference/rpc.js

@@ -0,0 +1,122 @@
+import { SemanticReferenceBridge } from "./bridge.js";
+import { CHANNEL, closed, MAX_WIRE_BYTES, modelMarker, parseCandidatesRequest, parseEnvelope, } from "./contracts.js";
+import { search } from "./search.js";
+import { workspaceKey } from "./usage.js";
+/** Abort the caller's wait, without pretending to cancel the shared Environment resolver. */
+export async function abortable(promise, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            signal.removeEventListener('abort', abort);
+            reject(new Error('cancelled'));
+        };
+        signal.addEventListener('abort', abort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener('abort', abort);
+            if (signal.aborted)
+                reject(new Error('cancelled'));
+            else
+                resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', abort);
+            reject(error);
+        });
+        if (signal.aborted)
+            abort();
+    });
+}
+export class SemanticReferenceService {
+    #resolve;
+    #usage;
+    #bridge;
+    #controller = new AbortController();
+    #closed = false;
+    constructor(resolve, usage, bridge = new SemanticReferenceBridge()) {
+        this.#resolve = resolve;
+        this.#usage = usage;
+        this.#bridge = bridge;
+    }
+    async #environment(sessionId, signal, purpose = 'reference') {
+        const runner = await abortable(this.#resolve(sessionId, purpose), signal);
+        if (runner.status !== 'ready') {
+            this.#bridge.invalidate(runner.binding.fingerprint);
+            throw new Error('environment-failed');
+        }
+        return runner;
+    }
+    async #owner(envelope, signal) {
+        const runner = await this.#environment(envelope.sessionId, signal);
+        if (runner.binding.fingerprint !== envelope.environmentFingerprint)
+            throw new Error('environment-mismatch');
+        return runner;
+    }
+    async handle(endpoint, payload, caller) {
+        if (this.#closed)
+            throw new Error('disposed');
+        const signal = AbortSignal.any([caller, this.#controller.signal]);
+        signal.throwIfAborted();
+        if (Buffer.byteLength(JSON.stringify(payload) ?? '') > MAX_WIRE_BYTES)
+            throw new Error('invalid-request');
+        if (endpoint === 'semantic-references/candidates') {
+            const request = parseCandidatesRequest(payload);
+            const environment = await this.#environment(request.sessionId, signal, 'candidates');
+            const projection = await this.#bridge.candidates(environment, signal);
+            const scores = await abortable(this.#usage.scores(workspaceKey(environment.binding.projectRoot)), signal);
+            // A live Agent may disappear or change binding while Catalog/storage work awaits.
+            const current = await this.#environment(request.sessionId, signal);
+            if (current.binding.fingerprint !== environment.binding.fingerprint)
+                throw new Error('environment-mismatch');
+            return {
+                environmentFingerprint: environment.binding.fingerprint,
+                items: search(projection, request.query, scores),
+            };
+        }
+        if (endpoint === 'semantic-references/selected' ||
+            endpoint === 'semantic-references/serialize') {
+            const request = closed(payload, ['envelope']), envelope = parseEnvelope(request.envelope);
+            const environment = await this.#owner(envelope, signal);
+            if (endpoint === 'semantic-references/serialize')
+                return { text: modelMarker(envelope) };
+            await this.#usage.selected(workspaceKey(environment.binding.projectRoot), envelope.ref, signal);
+            return { selected: true };
+        }
+        throw new Error('unknown-endpoint');
+    }
+    stop() {
+        this.#closed = true;
+        this.#controller.abort();
+        this.#bridge.dispose();
+    }
+    async close() {
+        this.stop();
+        await this.#usage.close();
+    }
+}
+export function registerSemanticReferenceRpc(connection, service, browser) {
+    const unregister = connection.rpc.handle(CHANNEL, async (endpoint, payload, signal) => {
+        if (browser && endpoint === 'semantic-browser/catalog') {
+            return browser(endpoint, payload, signal);
+        }
+        try {
+            return { ok: true, value: await service.handle(endpoint, payload, signal) };
+        }
+        catch {
+            return {
+                ok: false,
+                error: {
+                    code: 'internal',
+                    message: 'Marivo semantic reference request failed',
+                    details: {},
+                },
+            };
+        }
+    }, { authority: 'trusted-host' });
+    return async () => {
+        service.stop();
+        try {
+            await unregister();
+        }
+        finally {
+            await service.close();
+        }
+    };
+}

package/lib/semantic-reference/search.js

@@ -0,0 +1,94 @@
+import { LIMIT } from "./contracts.js";
+export function normalize(text) {
+    return text.normalize('NFKC').toLowerCase().trim().replace(/\s+/gu, ' ');
+}
+function tokens(text) {
+    return text.split(/[\s.:_-]+/u).filter(Boolean);
+}
+export function compareText(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function length(text) {
+    return Array.from(text).length;
+}
+export function dice(a, b) {
+    const grams = (text) => {
+        const chars = Array.from(text);
+        return new Set(chars.slice(0, -2).map((_, i) => chars.slice(i, i + 3).join('')));
+    };
+    const left = grams(a), right = grams(b);
+    if (!left.size || !right.size)
+        return 0;
+    return (2 * [...left].filter((gram) => right.has(gram)).length) / (left.size + right.size);
+}
+function match(item, query) {
+    const name = normalize(item.name), path = normalize(item.ref.path), key = normalize(item.refKey);
+    const fields = [name, path, key];
+    const all = [...fields, normalize(item.ref.kind)];
+    const searchTokens = all.flatMap(tokens);
+    if (fields.includes(query))
+        return { item, tier: 0, score: 1, field: 0 };
+    const prefixes = [...fields, ...searchTokens]
+        .map((value, field) => ({ value, field }))
+        .filter(({ value }) => value.startsWith(query));
+    if (prefixes.length) {
+        prefixes.sort((a, b) => length(a.value) - length(b.value) || a.field - b.field);
+        const best = prefixes[0];
+        return {
+            item,
+            tier: 1,
+            score: length(query) / length(best.value),
+            field: best.field < 3 ? best.field : 3,
+        };
+    }
+    const document = [...all, normalize(item.businessDefinition ?? '')].join(' ');
+    const qt = tokens(query);
+    if (qt.length && qt.every((token) => document.includes(token)))
+        return {
+            item,
+            tier: 2,
+            score: qt.reduce((sum, token) => sum + length(token), 0) / Math.max(1, length(document)),
+            field: 0,
+        };
+    return {
+        item,
+        tier: 3,
+        score: length(query) < 3
+            ? 0
+            : Math.max(...[name, ...tokens(path), path].map((value) => dice(query, value))),
+        field: 0,
+    };
+}
+export function search(projection, rawQuery, usage = new Map()) {
+    const query = normalize(rawQuery);
+    const heat = (a, b) => (usage.get(b.refKey)?.count ?? 0) - (usage.get(a.refKey)?.count ?? 0) ||
+        (usage.get(b.refKey)?.last ?? 0) - (usage.get(a.refKey)?.last ?? 0);
+    const fallback = (a, b) => projection.kinds.indexOf(a.ref.kind) - projection.kinds.indexOf(b.ref.kind) ||
+        compareText(a.refKey, b.refKey);
+    if (!query) {
+        const recent = projection.items
+            .filter((item) => (usage.get(item.refKey)?.count ?? 0) > 0)
+            .sort((a, b) => heat(a, b) || fallback(a, b))
+            .slice(0, 10);
+        const keys = new Set(recent.map((item) => item.refKey));
+        return [
+            ...recent.map((item) => ({ ...item, section: 'recent' })),
+            ...projection.items
+                .filter((item) => !keys.has(item.refKey))
+                .sort(fallback)
+                .slice(0, LIMIT - recent.length)
+                .map((item) => ({ ...item, section: 'kind' })),
+        ];
+    }
+    const matches = projection.items.map((item) => match(item, query));
+    const strictCount = matches.filter((item) => item.tier < 3).length;
+    return matches
+        .filter((m) => m.tier < 3 || (strictCount < 12 && m.score >= 0.42))
+        .sort((a, b) => a.tier - b.tier ||
+        b.score - a.score ||
+        a.field - b.field ||
+        heat(a.item, b.item) ||
+        compareText(a.item.refKey, b.item.refKey))
+        .slice(0, LIMIT)
+        .map((m) => ({ ...m.item, section: m.tier === 3 ? 'fuzzy' : 'strict' }));
+}

package/lib/semantic-reference/usage.js

@@ -0,0 +1,143 @@
+import { createHash } from 'node:crypto';
+import { defineDomain, domainTable, } from '@deepseek-ai/dsh-storage-domain';
+import { z } from 'zod';
+import { parseRef, refKey } from "./contracts.js";
+const refSchema = z.unknown().transform((value, ctx) => {
+    try {
+        return parseRef(value);
+    }
+    catch {
+        ctx.addIssue({ code: 'custom', message: 'invalid semantic ref' });
+        return z.NEVER;
+    }
+});
+const daySchema = z.strictObject({
+    day: z.iso.date(),
+    count: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+});
+export const usageSchema = z
+    .strictObject({
+    entries: z.record(z.string(), z.strictObject({
+        ref: refSchema,
+        days: z
+            .array(daySchema)
+            .min(1)
+            .max(7)
+            .refine((days) => days.every((day, i) => i === 0 || days[i - 1].day < day.day)),
+        lastSelectedAt: z.number().int().min(0).max(8_640_000_000_000_000),
+    })),
+})
+    .refine((row) => Object.entries(row.entries).every(([key, entry]) => key === refKey(entry.ref)));
+export const usageSpec = defineDomain({
+    name: 'dsh_data_analysis_semantic_reference_usage',
+    version: 0,
+    tables: { workspaces: domainTable(usageSchema) },
+});
+export function workspaceKey(canonicalRoot) {
+    return createHash('sha256').update(canonicalRoot).digest('hex');
+}
+export function localDay(date) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+}
+export function windowDays(now) {
+    const date = new Date(now);
+    date.setHours(12, 0, 0, 0);
+    return Array.from({ length: 7 }, (_, i) => {
+        const d = new Date(date);
+        d.setDate(d.getDate() - (6 - i));
+        return localDay(d);
+    });
+}
+export function increment(row, input, now) {
+    const ref = parseRef(input), window = windowDays(now), today = window[6];
+    const entries = Object.create(null);
+    for (const [key, value] of Object.entries(row.entries)) {
+        const days = value.days.filter((day) => window.includes(day.day));
+        if (days.length)
+            entries[key] = { ...value, days };
+    }
+    const key = refKey(ref), prior = entries[key], days = prior?.days ?? [];
+    const count = days.find((day) => day.day === today)?.count ?? 0;
+    entries[key] = {
+        ref,
+        days: [
+            ...days.filter((day) => day.day !== today),
+            { day: today, count: Math.min(Number.MAX_SAFE_INTEGER, count + 1) },
+        ].sort((a, b) => a.day.localeCompare(b.day)),
+        lastSelectedAt: now,
+    };
+    return { entries };
+}
+/** Only admitted mutations join the per-Workspace queue; close drains those jobs. */
+export class SemanticReferenceUsage {
+    #ready;
+    #queues = new Map();
+    #clock;
+    #diagnostic;
+    #closed = false;
+    constructor(facility, clock = Date.now, diagnostic = () => { }) {
+        this.#clock = clock;
+        this.#diagnostic = diagnostic;
+        this.#ready = Promise.resolve()
+            .then(() => facility.open(usageSpec))
+            .catch(() => {
+            diagnostic();
+            return undefined;
+        });
+    }
+    async scores(key) {
+        try {
+            const domain = await this.#ready;
+            if (!domain || this.#closed)
+                return new Map();
+            const window = windowDays(this.#clock()), row = domain.table('workspaces').get(key);
+            return new Map(Object.entries(row?.entries ?? {}).map(([key, entry]) => [
+                key,
+                {
+                    count: entry.days
+                        .filter((day) => window.includes(day.day))
+                        .reduce((sum, day) => Math.min(Number.MAX_SAFE_INTEGER, sum + day.count), 0),
+                    last: entry.lastSelectedAt,
+                },
+            ]));
+        }
+        catch {
+            this.#diagnostic();
+            return new Map();
+        }
+    }
+    async selected(key, ref, signal) {
+        const parsed = parseRef(ref);
+        const domain = await this.#ready;
+        signal.throwIfAborted();
+        if (this.#closed)
+            throw new Error('disposed');
+        if (!domain)
+            return;
+        const now = this.#clock();
+        const job = (this.#queues.get(key) ?? Promise.resolve())
+            .then(async () => {
+            const table = domain.table('workspaces');
+            if (table.get(key) === undefined)
+                await table.put(key, increment({ entries: {} }, parsed, now));
+            else
+                await table.update(key, (row) => increment(row, parsed, now));
+        })
+            .catch(() => {
+            this.#diagnostic();
+        });
+        this.#queues.set(key, job);
+        try {
+            await job;
+        }
+        finally {
+            if (this.#queues.get(key) === job)
+                this.#queues.delete(key);
+        }
+    }
+    async close() {
+        this.#closed = true;
+        await Promise.all(this.#queues.values());
+        await (await this.#ready)?.close();
+    }
+}

package/lib/types/bridges.d.ts

@@ -1,11 +1,11 @@
 import { MarivoDatasourceBridge } from './datasource/bridge.ts';
 import { MarivoHelpBridge } from './disclosure/bridge.ts';
 import type { MarivoEnvironment } from './environment/binding.ts';
-import { MarivoEvidenceBridge } from './evidence/bridge.ts';
+import { MarivoPresentationProjection } from './presentation/projection/index.ts';
 export interface MarivoBridgeSet {
     readonly help: MarivoHelpBridge;
     readonly datasource: MarivoDatasourceBridge;
-    readonly evidence: MarivoEvidenceBridge;
+    readonly presentation: MarivoPresentationProjection;
 }
 /** Compose domain adapters without adding domain methods back to the Environment. */
 export declare function createMarivoBridgeSet(environment: MarivoEnvironment): MarivoBridgeSet;

package/lib/types/client/credentials/create-datasource.d.ts

@@ -0,0 +1,5 @@
+export declare function CreateDatasource({ model, workspaceId, close }: {
+    model: any;
+    workspaceId: any;
+    close: any;
+}): import("react").JSX.Element;

package/lib/types/client/credentials/install.d.ts

@@ -0,0 +1 @@
+export declare function installCredentials(ctx: any, rpc: any): void;

package/lib/types/client/credentials/model.d.ts

@@ -0,0 +1,59 @@
+import type { DatasourceAuthoring, DatasourceCreateInput } from '../../datasource/authoring.ts';
+import type { CredentialAction, CredentialContextView, CredentialOperationView, CredentialRequestView } from '../../datasource/service.ts';
+import type { BrowserRpc } from '../semantic-browser/model.ts';
+interface QueryHandle {
+    generation: string;
+    id: string;
+    scope: string;
+}
+export interface ClientOperation {
+    handle: QueryHandle;
+    name: string;
+    workspaceId?: string;
+    overviewUpdated?: boolean;
+    error?: string;
+    operation?: CredentialOperationView;
+}
+export interface CredentialClientState {
+    open: boolean;
+    workspaceId: string;
+    sessionId: string;
+    generation: string;
+    datasources: CredentialContextView[];
+    requests: CredentialRequestView[];
+    requestId: string;
+    selected: string;
+    loading: boolean;
+    error: string;
+    operations: ClientOperation[];
+    outcomes: Record<string, ClientOperation>;
+    operation?: CredentialOperationView;
+    handle?: QueryHandle;
+}
+export declare function credentialMessage(code: string): string;
+export declare class CredentialClientModel {
+    #private;
+    constructor(rpc: BrowserRpc, storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>);
+    getSnapshot: () => CredentialClientState;
+    subscribe: (listener: () => void) => (() => void);
+    show(workspaceId: string): void;
+    authoring(workspaceId: string, signal: AbortSignal): Promise<DatasourceAuthoring & {
+        generation: string;
+    }>;
+    createDatasource(workspaceId: string, schema: DatasourceAuthoring & {
+        generation: string;
+    }, input: DatasourceCreateInput): Promise<void>;
+    close(): void;
+    openRequest(id: string): void;
+    select(token: string): void;
+    selectWorkspace(workspaceId: string): Promise<void>;
+    session(sessionId: string): void;
+    selectOperation(id: string): void;
+    start(context: CredentialContextView, action: CredentialAction, changes?: Record<string, string>, reference?: string): Promise<void>;
+    recover(): void;
+    cancelRequest(id: string): Promise<void>;
+    cancelOperation(scope?: string): Promise<void>;
+    reset(): void;
+    dispose(): void;
+}
+export {};