@qvac/core 0.0.0 → 0.1.1

package/dist-lib/lib/run-transcript.js

@@ -0,0 +1,106 @@
+import { WriteQueue } from "./write-queue.js";
+const COALESCE_CAP = 8192;
+const FLUSH_INTERVAL_MS = 250;
+const SLOW_WRITE_MS = 5000;
+const TRANSCRIPT = 'transcript';
+const STATUS = 'status';
+export class RunTranscript {
+    _engine;
+    _chatId;
+    _runId;
+    _deviceId;
+    _model;
+    _log;
+    _writes;
+    _ticker;
+    _announced = new Set();
+    _buffered = null;
+    constructor(engine, { chatId, runId, deviceId, model, log }) {
+        this._engine = engine;
+        this._chatId = chatId;
+        this._runId = runId;
+        this._deviceId = deviceId;
+        this._model = model;
+        this._log = log ?? null;
+        this._writes = new WriteQueue({
+            slowMs: SLOW_WRITE_MS,
+            onSlow: (info) => this._log?.warn('runs', 'write still pending', { runId, ...info })
+        });
+        this._ticker = setInterval(() => {
+            this.flush().catch((err) => this._log?.error('assistant', 'content flush failed', err));
+        }, FLUSH_INTERVAL_MS);
+    }
+    async text(type, text) {
+        if (this._buffered && this._buffered.type !== type)
+            await this.flush();
+        if (!this._buffered) {
+            this._buffered = { type, text: '' };
+            this._announce(type);
+        }
+        this._buffered.text += text;
+        if (this._buffered.text.length >= COALESCE_CAP)
+            await this.flush();
+    }
+    chunk(chunk) {
+        return this._writes.run(TRANSCRIPT, `append:${chunk.type}`, () => this._engine.appendChunk({
+            chatId: this._chatId,
+            runId: this._runId,
+            originDeviceId: this._deviceId,
+            ...chunk
+        }));
+    }
+    status(runStatus) {
+        this._log?.info('runs', `run ${runStatus.state}`, {
+            runId: this._runId,
+            chatId: this._chatId,
+            reason: runStatus.reason || undefined
+        });
+        return this._writes.run(STATUS, `status:${runStatus.state}`, () => this._engine.appendChunk({
+            chatId: this._chatId,
+            runId: this._runId,
+            type: 'run-status',
+            runStatus: { ...runStatus, model: this._model },
+            originDeviceId: this._deviceId
+        }));
+    }
+    progress(id, runStatus) {
+        return this._writes.run(TRANSCRIPT, 'update:run-status', () => this._engine.updateChunk({ id, runStatus: { ...runStatus, model: this._model } }));
+    }
+    flush() {
+        return this._writes.run(TRANSCRIPT, 'append:text', async () => {
+            if (!this._buffered)
+                return;
+            const { type, text } = this._buffered;
+            this._buffered = null;
+            const started = Date.now();
+            await this._engine.appendChunk({
+                chatId: this._chatId,
+                runId: this._runId,
+                type,
+                content: type === 'content' ? { text } : null,
+                thinking: type === 'thinking' ? { text } : null,
+                originDeviceId: this._deviceId
+            });
+            const ms = Date.now() - started;
+            if (ms > FLUSH_INTERVAL_MS) {
+                this._log?.warn('runs', 'slow content flush', {
+                    runId: this._runId,
+                    ms,
+                    chars: text.length
+                });
+            }
+        });
+    }
+    pending() {
+        return this._writes.pending();
+    }
+    close() {
+        clearInterval(this._ticker);
+    }
+    _announce(type) {
+        if (this._announced.has(type))
+            return;
+        this._announced.add(type);
+        this._log?.info('runs', `${type} started`, { runId: this._runId });
+    }
+}

package/dist-lib/lib/skill-readiness.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeAgentSkillReadiness(agentId: string, readySkillNames: ReadonlyArray<string>): string[];
+export declare function agentReadySkillNames(reported: ReadonlyArray<string> | null | undefined, agentId: string | null | undefined): ReadonlyArray<string> | null;

package/dist-lib/lib/skill-readiness.js

@@ -0,0 +1,21 @@
+const AGENT_PREFIX = '\0agent-skill-readiness\0';
+function prefix(agentId) {
+    return `${AGENT_PREFIX}${agentId}\0`;
+}
+export function encodeAgentSkillReadiness(agentId, readySkillNames) {
+    const scoped = prefix(agentId);
+    return [scoped, ...readySkillNames.map((name) => `${scoped}${name}`)];
+}
+export function agentReadySkillNames(reported, agentId) {
+    if (reported === null || reported === undefined)
+        return null;
+    const unscoped = reported.filter((name) => !name.startsWith(AGENT_PREFIX));
+    if (!agentId || !reported.some((name) => name.startsWith(AGENT_PREFIX)))
+        return unscoped;
+    const scoped = prefix(agentId);
+    if (!reported.includes(scoped))
+        return unscoped;
+    return reported
+        .filter((name) => name !== scoped && name.startsWith(scoped))
+        .map((name) => name.slice(scoped.length));
+}

package/dist-lib/lib/skill-types.d.ts

@@ -0,0 +1,70 @@
+export type CapabilityProfile = 'tiny' | 'low' | 'mid' | 'high' | 'xhigh';
+export type SkillState = 'ready' | 'needs-setup' | 'failed' | 'disabled' | 'disconnected' | 'outdated' | 'incompatible-model' | 'unsupported';
+export type InstallStep = {
+    readonly id: string;
+    readonly kind: string;
+    readonly formula?: string | undefined;
+    readonly bins?: ReadonlyArray<string> | undefined;
+    readonly label: string;
+    readonly command?: string | undefined;
+    readonly manual?: boolean | undefined;
+};
+export type SkillTransport = {
+    readonly credentialKey: string;
+    readonly name: string;
+    readonly directive: string;
+};
+export type SkillSetupField = {
+    readonly key: string;
+    readonly label: string;
+    readonly placeholder?: string | undefined;
+    readonly secret?: boolean | undefined;
+    readonly required?: boolean | undefined;
+};
+export type SkillSetupRoute = {
+    readonly kind: 'oauth' | 'token' | 'install' | 'picker' | 'instructions';
+    readonly label: string;
+    readonly provider?: string | undefined;
+    readonly credentialKey?: string | undefined;
+    readonly description?: string | undefined;
+    readonly helpUrl?: string | undefined;
+    readonly steps?: ReadonlyArray<string> | undefined;
+    readonly configSteps?: ReadonlyArray<string> | undefined;
+    readonly fields?: ReadonlyArray<SkillSetupField> | undefined;
+    readonly satisfied?: boolean | undefined;
+};
+export type SkillSetup = {
+    readonly summary?: string | undefined;
+    readonly routes?: ReadonlyArray<SkillSetupRoute> | undefined;
+};
+export type SkillMetadata = {
+    readonly name: string;
+    readonly description: string;
+    readonly os?: ReadonlyArray<string> | undefined;
+    readonly requires?: {
+        readonly bins?: ReadonlyArray<string> | undefined;
+        readonly credentials?: ReadonlyArray<string> | undefined;
+        readonly binMinVersions?: Readonly<Record<string, {
+            readonly min: string;
+            readonly command?: string | undefined;
+        }>> | undefined;
+        readonly credentialChecks?: Readonly<Record<string, {
+            readonly url: string;
+            readonly method?: string | undefined;
+            readonly headers?: Readonly<Record<string, string>> | undefined;
+        }>> | undefined;
+    } | undefined;
+    readonly transports?: ReadonlyArray<SkillTransport> | undefined;
+    readonly install?: ReadonlyArray<InstallStep> | undefined;
+    readonly surfaceWhenUnsupported?: boolean | undefined;
+    readonly setup?: SkillSetup | undefined;
+    readonly stub?: boolean | undefined;
+    readonly tools?: ReadonlyArray<string> | undefined;
+    readonly minCapabilityProfile?: CapabilityProfile | undefined;
+};
+export type SkillEntry = {
+    readonly metadata: SkillMetadata;
+    readonly content: string;
+    readonly available: boolean;
+    readonly state: SkillState;
+};

package/dist-lib/lib/skill-types.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/spec-loader.d.ts

@@ -0,0 +1,14 @@
+import { bindApi } from '../spec/bind.js';
+import { engineClient } from '../spec/calls.js';
+import DefaultHRPC from '../spec/hrpc/index.js';
+export interface CoreSpec {
+    bindApi: typeof bindApi;
+    HRPC: typeof DefaultHRPC;
+}
+export interface EngineSpec {
+    engineClient: typeof engineClient;
+    bindApi: typeof bindApi;
+    HRPC: typeof DefaultHRPC;
+}
+export declare function openLocalSpec(): Promise<CoreSpec>;
+export declare function openLocalEngineSpec(): Promise<EngineSpec>;

package/dist-lib/lib/spec-loader.js

@@ -0,0 +1,9 @@
+import { bindApi } from '../spec/bind.js';
+import { engineClient } from '../spec/calls.js';
+import DefaultHRPC from '../spec/hrpc/index.js';
+export async function openLocalSpec() {
+    return { bindApi, HRPC: DefaultHRPC };
+}
+export async function openLocalEngineSpec() {
+    return { engineClient, bindApi, HRPC: DefaultHRPC };
+}

package/dist-lib/lib/suspend-lifecycle.d.ts

@@ -0,0 +1,17 @@
+import Suspendify from 'suspendify';
+export declare const ASSISTANT_WAKEUP_LINGER_MS = 6000;
+type LifecycleSupervisor = {
+    readonly opened: boolean;
+    ready(): Promise<void>;
+    presuspend(): Promise<void>;
+    suspend(): Promise<void>;
+    wakeup(): Promise<void>;
+    resume(): Promise<void>;
+};
+export type AssistantSuspendLifecycleOptions = {
+    readonly wakeupLinger?: number;
+    readonly pollLinger?: () => Promise<number> | number;
+    readonly onSuspended?: () => void;
+};
+export declare function createAssistantSuspendLifecycle(supervisor: LifecycleSupervisor, options?: AssistantSuspendLifecycleOptions): Suspendify;
+export {};

package/dist-lib/lib/suspend-lifecycle.js

@@ -0,0 +1,33 @@
+import Suspendify from 'suspendify';
+export const ASSISTANT_WAKEUP_LINGER_MS = 6_000;
+export function createAssistantSuspendLifecycle(supervisor, options = {}) {
+    const { wakeupLinger = ASSISTANT_WAKEUP_LINGER_MS, pollLinger, onSuspended = noop } = options;
+    const lifecycle = new Suspendify({
+        wakeupLinger,
+        pollLinger,
+        presuspend: async () => {
+            if (!supervisor.opened)
+                await supervisor.ready();
+            await supervisor.presuspend();
+        },
+        suspend: async () => {
+            if (!supervisor.opened)
+                await supervisor.ready();
+            await supervisor.suspend();
+            if (!lifecycle.interrupted)
+                onSuspended();
+        },
+        wakeup: async () => {
+            if (!supervisor.opened)
+                await supervisor.ready();
+            await supervisor.wakeup();
+        },
+        resume: async () => {
+            if (!supervisor.opened)
+                await supervisor.ready();
+            await supervisor.resume();
+        }
+    });
+    return lifecycle;
+}
+function noop() { }

package/dist-lib/lib/task.d.ts

@@ -0,0 +1,26 @@
+import type { Capabilities } from '../spec/capabilities.d.ts';
+import type { AssistantChunk, AssistantChunkContentAttachment, AssistantRagSource, AssistantRunState } from '../spec/hyperschema/types.d.ts';
+export type TaskEngine = Pick<Capabilities, 'chunksWatch' | 'sendMessage'>;
+export interface TaskRequest {
+    readonly agentId: string;
+    readonly prompt: string;
+    readonly chatId?: string;
+    readonly skill?: string;
+}
+export interface TaskToolCall {
+    readonly name: string;
+    readonly arguments: unknown;
+}
+export interface TaskResult {
+    readonly chatId: string;
+    readonly runId: string;
+    readonly state: AssistantRunState;
+    readonly text: string;
+    readonly thinking: string;
+    readonly toolCalls: ReadonlyArray<TaskToolCall>;
+    readonly attachments: ReadonlyArray<AssistantChunkContentAttachment>;
+    readonly sources: ReadonlyArray<AssistantRagSource>;
+    readonly reason: string | null;
+    readonly chunks: ReadonlyArray<AssistantChunk>;
+}
+export declare function runTask(engine: TaskEngine, request: TaskRequest): Promise<TaskResult>;

package/dist-lib/lib/task.js

@@ -0,0 +1,69 @@
+const TERMINAL_STATES = new Set(['completed', 'failed', 'canceled']);
+const TITLE_CHARS = 60;
+export async function runTask(engine, request) {
+    const { agentId, prompt, skill } = request;
+    const text = skill ? `@${skill} ${prompt}` : prompt;
+    const { chatId, runId } = await engine.sendMessage({
+        text,
+        agentId,
+        chatId: request.chatId ?? null,
+        title: request.chatId ? null : title(prompt)
+    });
+    for await (const frame of engine.chunksWatch({ chatId })) {
+        const chunks = frame.chunks ?? [];
+        const state = terminalState(chunks, runId);
+        if (state)
+            return collect(chatId, runId, state, chunks);
+    }
+    throw new Error(`chunk stream ended before the run settled: ${chatId}`);
+}
+function terminalState(chunks, runId) {
+    for (const chunk of chunks) {
+        const state = chunk.runId === runId ? chunk.runStatus?.state : undefined;
+        if (state && TERMINAL_STATES.has(state))
+            return state;
+    }
+    return null;
+}
+function collect(chatId, runId, state, all) {
+    const chunks = all.filter((chunk) => chunk.runId === runId);
+    const text = [];
+    const thinking = [];
+    const toolCalls = [];
+    const attachments = [];
+    const sources = [];
+    let reason = null;
+    for (const chunk of chunks) {
+        const call = chunk.toolCall;
+        if (chunk.type === 'tool-result')
+            text.length = 0;
+        if (chunk.content)
+            text.push(chunk.content.text);
+        if (chunk.thinking)
+            thinking.push(chunk.thinking.text);
+        if (call)
+            toolCalls.push({ name: call.name, arguments: call.arguments });
+        if (chunk.attachment && !chunk.attachment.deletedAt)
+            attachments.push(chunk.attachment);
+        if (chunk.sources)
+            sources.push(...chunk.sources.sources);
+        if (chunk.runStatus?.reason)
+            reason = chunk.runStatus.reason;
+    }
+    return {
+        chatId,
+        runId,
+        state,
+        text: text.join('').trim(),
+        thinking: thinking.join('').trim(),
+        toolCalls,
+        attachments,
+        sources,
+        reason,
+        chunks
+    };
+}
+function title(prompt) {
+    const line = prompt.trim().split('\n', 1)[0] ?? '';
+    return line.length > TITLE_CHARS ? `${line.slice(0, TITLE_CHARS)}…` : line;
+}

package/dist-lib/lib/unref.d.ts

@@ -0,0 +1,3 @@
+export declare function unref(timer: {
+    unref?: () => void;
+} | number): void;

package/dist-lib/lib/unref.js

@@ -0,0 +1,4 @@
+export function unref(timer) {
+    if (typeof timer !== 'number')
+        timer.unref?.();
+}

package/dist-lib/lib/wav-duration.d.ts

@@ -0,0 +1 @@
+export declare function wavDurationSeconds(head: Uint8Array, totalBytes: number): number | null;

package/dist-lib/lib/wav-duration.js

@@ -0,0 +1,53 @@
+const WAV_FORMAT_PCM = 1;
+const WAV_FORMAT_IEEE_FLOAT = 3;
+const RIFF_HEADER_BYTES = 12;
+const CHUNK_HEADER_BYTES = 8;
+function ascii(bytes, start, end) {
+    let out = '';
+    for (let i = start; i < end; i++)
+        out += String.fromCharCode(bytes[i] ?? 0);
+    return out;
+}
+function readWavHeader(head) {
+    if (head.length < RIFF_HEADER_BYTES)
+        return null;
+    if (ascii(head, 0, 4) !== 'RIFF' || ascii(head, 8, 12) !== 'WAVE')
+        return null;
+    const view = new DataView(head.buffer, head.byteOffset, head.byteLength);
+    let fmt = null;
+    let offset = RIFF_HEADER_BYTES;
+    while (offset + CHUNK_HEADER_BYTES <= head.length) {
+        const id = ascii(head, offset, offset + 4);
+        const size = view.getUint32(offset + 4, true);
+        const start = offset + CHUNK_HEADER_BYTES;
+        if (id === 'fmt ' && start + 16 <= head.length) {
+            fmt = {
+                format: view.getUint16(start, true),
+                channels: view.getUint16(start + 2, true),
+                sampleRate: view.getUint32(start + 4, true),
+                bitsPerSample: view.getUint16(start + 14, true)
+            };
+        }
+        else if (id === 'data') {
+            return fmt ? { ...fmt, dataStart: start, dataSize: size } : null;
+        }
+        offset = start + size + (size & 1);
+    }
+    return null;
+}
+export function wavDurationSeconds(head, totalBytes) {
+    const header = readWavHeader(head);
+    if (!header)
+        return null;
+    if (header.format !== WAV_FORMAT_PCM && header.format !== WAV_FORMAT_IEEE_FLOAT)
+        return null;
+    const frameBytes = header.channels * (header.bitsPerSample / 8);
+    if (!(frameBytes > 0) || !(header.sampleRate > 0))
+        return null;
+    const available = totalBytes - header.dataStart;
+    if (!(available > 0))
+        return null;
+    const dataBytes = header.dataSize > 0 && header.dataSize <= available ? header.dataSize : available;
+    const seconds = dataBytes / (header.sampleRate * frameBytes);
+    return Number.isFinite(seconds) && seconds > 0 ? seconds : null;
+}

package/dist-lib/lib/write-queue.d.ts

@@ -0,0 +1,22 @@
+export interface WriteQueueOptions {
+    slowMs?: number;
+    onSlow?: (info: {
+        scope: string;
+        write: string;
+        waiting: number;
+        afterMs: number;
+    }) => void;
+}
+export declare class WriteQueue {
+    private readonly _scopes;
+    private readonly _slowMs;
+    private readonly _onSlow;
+    constructor({ slowMs, onSlow }?: WriteQueueOptions);
+    run<T>(name: string, write: string, task: () => Promise<T>): Promise<T>;
+    pending(): Array<{
+        scope: string;
+        waiting: number;
+    }>;
+    private _enter;
+    private _leave;
+}

package/dist-lib/lib/write-queue.js

@@ -0,0 +1,39 @@
+import ScopeLock from 'scope-lock';
+export class WriteQueue {
+    _scopes = new Map();
+    _slowMs;
+    _onSlow;
+    constructor({ slowMs = 5000, onSlow } = {}) {
+        this._slowMs = slowMs;
+        this._onSlow = onSlow;
+    }
+    async run(name, write, task) {
+        const scope = this._enter(name);
+        await scope.lock.lock();
+        const slow = setTimeout(() => {
+            this._onSlow?.({ scope: name, write, waiting: scope.waiting, afterMs: this._slowMs });
+        }, this._slowMs);
+        try {
+            return await task();
+        }
+        finally {
+            clearTimeout(slow);
+            scope.lock.unlock();
+            this._leave(name, scope);
+        }
+    }
+    pending() {
+        return [...this._scopes].map(([name, scope]) => ({ scope: name, waiting: scope.waiting }));
+    }
+    _enter(name) {
+        const scope = this._scopes.get(name) ?? { lock: new ScopeLock(), waiting: 0 };
+        scope.waiting++;
+        this._scopes.set(name, scope);
+        return scope;
+    }
+    _leave(name, scope) {
+        scope.waiting--;
+        if (scope.waiting === 0 && this._scopes.get(name) === scope)
+            this._scopes.delete(name);
+    }
+}

package/dist-lib/schema/build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-lib/schema/build.js

@@ -0,0 +1,120 @@
+import fs from 'bare-fs';
+import path from 'bare-path';
+import { fileURLToPath } from 'bare-url';
+import regen from 'hyperschema-regen';
+import HRPCBuilder from 'hrpc';
+import Hyperconf from 'hyperconf/builder';
+import Hyperdispatch from 'hyperdispatch';
+import Hyperschema from 'hyperschema';
+import HyperschemaTS from 'hyperschema-ts';
+import HyperDB from 'hyperdb/builder';
+import { resetHrpcIds, rewindSpec, unstageSpec } from '@qvac/harness/schema/baseline';
+import { assertFieldOrder } from "./field-order.js";
+import { VENDORED_MIN_SUPPORTED_VERSION, registerConfigTypes } from "./config.js";
+import { registerEngineApi, registerEngineTypes } from "./engine.js";
+import { writeBind, writeCapabilities, writeClient, writeConfigTypes } from '@qvac/harness/schema/generate';
+import { registerLocalCollections, registerLocalTypes } from "./local.js";
+import { registerQvacCollections, registerQvacDispatch, registerQvacTypes } from "./qvac.js";
+const dir = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.join(dir, '..');
+const SPEC_DIR = path.join(dir, '..', 'spec');
+const SCHEMA_DIR = path.join(SPEC_DIR, 'hyperschema');
+const HRPC_DIR = path.join(SPEC_DIR, 'hrpc');
+const LOCAL_DIR = path.join(SPEC_DIR, 'local');
+const LOCAL_SCHEMA_DIR = path.join(LOCAL_DIR, 'hyperschema');
+const LOCAL_DB_DIR = path.join(LOCAL_DIR, 'hyperdb');
+const MESH_DIR = path.join(SPEC_DIR, 'mesh');
+const MESH_SCHEMA_DIR = path.join(MESH_DIR, 'hyperschema');
+const MESH_DB_DIR = path.join(MESH_DIR, 'hyperdb');
+const MESH_DISPATCH_DIR = path.join(MESH_DIR, 'hyperdispatch');
+const CONFIG_SCHEMA_DIR = path.join(SPEC_DIR, 'config', 'hyperschema');
+const CONFIG_CONF_DIR = path.join(SPEC_DIR, 'config', 'hyperconf');
+const MESH_DB_JSON = path.join(MESH_DB_DIR, 'db.json');
+const MESH_DISPATCH_JSON = path.join(MESH_DISPATCH_DIR, 'dispatch.json');
+const LOCAL_DB_JSON = path.join(LOCAL_DB_DIR, 'db.json');
+const MESH_SCHEMA_JSON = path.join(MESH_SCHEMA_DIR, 'schema.json');
+const BASELINE_DIRS = [SPEC_DIR];
+const HAND_WRITTEN = [
+    'spec/index.js',
+    'spec/index.d.ts',
+    'spec/calls.d.ts',
+    'spec/bind.d.ts',
+    'spec/hrpc/index.d.ts',
+    'spec/hrpc/messages.d.ts',
+    'spec/mesh/hyperdispatch/index.d.ts',
+    'spec/mesh/hyperdb/index.d.ts',
+    'spec/local/hyperdb/index.d.ts',
+    'spec/hyperschema/index.d.ts',
+    'spec/mesh/hyperschema/index.d.ts'
+];
+const baselines = rewindSpec(ROOT, BASELINE_DIRS, {
+    carries: 'spec/mesh/hyperdb/db.json',
+    keep: HAND_WRITTEN
+});
+const engineSchemaFile = path.join(SCHEMA_DIR, 'schema.json');
+const engineSchema = JSON.parse(fs.readFileSync(engineSchemaFile, 'utf8'));
+const chatEnvelope = engineSchema.schema.find((type) => type.name === 'notification');
+if (chatEnvelope?.fields?.some((field) => field.name === 'chatId' && field.required)) {
+    engineSchema.schema = engineSchema.schema.filter((type) => !type.name.startsWith('notification'));
+    fs.writeFileSync(engineSchemaFile, JSON.stringify(engineSchema, null, 2));
+}
+const schema = Hyperschema.from(SCHEMA_DIR);
+registerEngineTypes(schema.namespace('assistant'));
+Hyperschema.toDisk(schema, { esm: true });
+HyperschemaTS.toDisk(schema);
+resetHrpcIds(HRPC_DIR);
+const builder = HRPCBuilder.from(SCHEMA_DIR, HRPC_DIR);
+registerEngineApi(builder.namespace('assistant'));
+HRPCBuilder.toDisk(builder);
+writeBind(builder, path.join(SPEC_DIR, 'bind.js'));
+writeClient(builder, path.join(SPEC_DIR, 'calls.js'));
+writeCapabilities(builder, path.join(SPEC_DIR, 'capabilities.d.ts'));
+const localSchema = Hyperschema.from(LOCAL_SCHEMA_DIR);
+registerLocalTypes(localSchema.namespace('local'));
+Hyperschema.toDisk(localSchema, { esm: true });
+HyperschemaTS.toDisk(localSchema);
+const db = HyperDB.from(LOCAL_SCHEMA_DIR, LOCAL_DB_DIR);
+registerLocalCollections(db.namespace('local'));
+HyperDB.toDisk(db, { esm: true });
+const meshSchema = Hyperschema.from(MESH_SCHEMA_DIR);
+registerQvacTypes(meshSchema.namespace('qvac'));
+Hyperschema.toDisk(meshSchema, { esm: true });
+HyperschemaTS.toDisk(meshSchema);
+const meshDb = HyperDB.from(MESH_SCHEMA_DIR, MESH_DB_DIR);
+registerQvacCollections(meshDb.namespace('qvac'), path.join(dir, 'helpers.js'));
+HyperDB.toDisk(meshDb, { esm: true });
+const dispatch = Hyperdispatch.from(MESH_SCHEMA_DIR, MESH_DISPATCH_DIR);
+registerQvacDispatch(dispatch.namespace('qvac'));
+Hyperdispatch.toDisk(dispatch);
+const configSchema = Hyperschema.from(CONFIG_SCHEMA_DIR);
+registerConfigTypes(configSchema.namespace('conf'));
+Hyperschema.toDisk(configSchema);
+const config = Hyperconf.from(CONFIG_SCHEMA_DIR, CONFIG_CONF_DIR);
+config.setProduction('@conf/config', { minSupportedVersion: VENDORED_MIN_SUPPORTED_VERSION });
+Hyperconf.toDisk(config);
+fs.writeFileSync(path.join(CONFIG_CONF_DIR, 'package.json'), `${JSON.stringify({ type: 'commonjs' }, null, 2)}\n`);
+writeConfigTypes(path.join(CONFIG_CONF_DIR, 'index.d.ts'));
+for (const file of [MESH_DISPATCH_JSON, MESH_DB_JSON, LOCAL_DB_JSON])
+    assertUniqueIds(file);
+try {
+    for (const tag of baselines) {
+        regen.validate(MESH_DB_JSON, LOCAL_DB_JSON, MESH_DISPATCH_JSON, { tag });
+    }
+    if (baselines.length > 0)
+        assertFieldOrder(ROOT, MESH_SCHEMA_JSON, baselines);
+}
+finally {
+    if (baselines.length > 0)
+        unstageSpec(ROOT, BASELINE_DIRS);
+}
+console.log('assistant schema + hrpc + bind + client + local + mesh hyperdb generated under spec/');
+function assertUniqueIds(file) {
+    const { schema } = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const byId = new Map();
+    for (const { id, name } of schema) {
+        const clash = byId.get(id);
+        if (clash)
+            throw new Error(`${path.basename(file)}: id ${id} is on both ${clash} and ${name}`);
+        byId.set(id, name);
+    }
+}

package/dist-lib/schema/config.d.ts

@@ -0,0 +1,4 @@
+export declare function registerConfigTypes(ns: {
+    register: (spec: Record<string, unknown>) => void;
+}): void;
+export declare const VENDORED_MIN_SUPPORTED_VERSION = ">=0.18.0";

package/dist-lib/schema/config.js

@@ -0,0 +1,7 @@
+export function registerConfigTypes(ns) {
+    ns.register({
+        name: 'config',
+        fields: [{ name: 'minSupportedVersion', type: 'string', required: true }]
+    });
+}
+export const VENDORED_MIN_SUPPORTED_VERSION = '>=0.18.0';

package/dist-lib/schema/content.d.ts

@@ -0,0 +1,20 @@
+export declare const CHUNK_TYPES: string[];
+export declare const RUN_STATES: string[];
+export declare const APPROVAL_STATUSES: string[];
+export declare const CHUNK_PAYLOAD_FIELDS: {
+    readonly 'user-message': "userMessage";
+    readonly content: "content";
+    readonly thinking: "thinking";
+    readonly 'tool-call': "toolCall";
+    readonly 'tool-result': "toolResult";
+    readonly attachment: "attachment";
+    readonly 'approval-request': "approvalRequest";
+    readonly 'run-status': "runStatus";
+    readonly 'run-request': "runRequest";
+    readonly sources: "sources";
+    readonly compaction: "compaction";
+};
+export type ChunkType = keyof typeof CHUNK_PAYLOAD_FIELDS;
+export type ChunkPayloadField = (typeof CHUNK_PAYLOAD_FIELDS)[ChunkType];
+export declare function versionedRegistrar(ns: any, namespace: string): (name: string, fields: any[]) => void;
+export declare function registerContentTypes(ns: any, namespace: string): void;