@qvac/core 0.0.0 → 0.1.0

package/dist-lib/schema/field-order.d.ts

@@ -0,0 +1 @@
+export declare function assertFieldOrder(root: string, schemaFile: string, tags: readonly string[]): void;

package/dist-lib/schema/field-order.js

@@ -0,0 +1,95 @@
+import fs from 'bare-fs';
+import { spawnSync } from 'bare-subprocess';
+const EXEMPT = {};
+export function assertFieldOrder(root, schemaFile, tags) {
+    const current = index(JSON.parse(fs.readFileSync(schemaFile, 'utf8')).schema);
+    const seen = new Set();
+    for (const tag of tags) {
+        const baseline = index(JSON.parse(show(root, tag, schemaFile)).schema);
+        for (const finding of shifts(baseline, current)) {
+            const reason = EXEMPT[finding.at];
+            if (!reason) {
+                throw new Error(`${finding.at} grew ${finding.grew.join(',')} against ${tag}, and ${finding.behind.join(',')} ` +
+                    'ship behind it. Append to the container instead, or exempt it in schema/field-order.ts ' +
+                    'naming the code that keeps the field off the wire.');
+            }
+            seen.add(finding.at);
+        }
+        const risky = [...latent(baseline, current)];
+        if (risky.length > 0) {
+            const containers = [...new Set(risky.map((at) => at.split('.')[0]))];
+            console.log(`field-order: ${risky.length} embedded records in ${containers.join(', ')} carry shipped ` +
+                `fields behind them against ${tag}, safe until one of them grows`);
+        }
+    }
+    for (const at of Object.keys(EXEMPT)) {
+        if (!seen.has(at)) {
+            throw new Error(`${at} is exempt in schema/field-order.ts but no longer shifts`);
+        }
+    }
+}
+function show(root, tag, file) {
+    const at = file.slice(root.length + 1);
+    const done = spawnSync('git', ['show', `${tag}:${at}`], { cwd: root });
+    if (done.status !== 0)
+        throw new Error(`git show ${tag}:${at} failed: ${done.stderr ?? ''}`);
+    return String(done.stdout);
+}
+function index(schema) {
+    return new Map(schema.map((type) => [`@${type.namespace}/${type.name}`, type]));
+}
+function* shifts(baseline, current) {
+    for (const [name, container] of embeds(baseline, current)) {
+        const grew = grown(baseline, current, container.type);
+        if (grew.length > 0)
+            yield { at: name, grew, behind: container.behind };
+    }
+}
+function* latent(baseline, current) {
+    for (const [name, container] of embeds(baseline, current)) {
+        if (grown(baseline, current, container.type).length === 0)
+            yield name;
+    }
+}
+function* embeds(baseline, current) {
+    for (const [name, type] of current) {
+        const shipped = baseline.get(name);
+        if (!shipped?.fields || !type.fields)
+            continue;
+        const known = new Set(shipped.fields.map((field) => field.name));
+        for (let i = 0; i < type.fields.length; i++) {
+            const field = type.fields[i];
+            if (!current.get(field.type)?.versions)
+                continue;
+            const behind = type.fields
+                .slice(i + 1)
+                .map((later) => later.name)
+                .filter((later) => known.has(later));
+            if (field.array && known.has(field.name))
+                behind.unshift('its own later elements');
+            if (behind.length > 0)
+                yield [`${name}.${field.name}`, { type: field.type, behind }];
+        }
+    }
+}
+function grown(baseline, current, name) {
+    const shipped = baseline.get(name);
+    const now = current.get(name);
+    if (!shipped?.versions || !now?.versions)
+        return [];
+    const out = [];
+    for (const version of shipped.versions) {
+        const mine = now.versions.find((entry) => entry.version === version.version);
+        if (!mine)
+            continue;
+        const was = baseline.get(version.type);
+        const is = current.get(mine.type);
+        if (!was?.fields || !is?.fields)
+            continue;
+        const before = was.fields.map((field) => field.name);
+        out.push(...is.fields.map((field) => field.name).filter((field) => !before.includes(field)));
+        if (was.flagsPosition === -1 && (is.flagsPosition ?? -1) >= 0)
+            out.push('(flags byte)');
+    }
+    return out;
+}

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

@@ -0,0 +1,2 @@
+export declare function registerLocalTypes(ns: any): void;
+export declare function registerLocalCollections(dbns: any): void;

package/dist-lib/schema/local.js

@@ -0,0 +1,133 @@
+import { versionedRegistrar } from "./content.js";
+import { CAPABILITY_PROFILES } from "./qvac.js";
+export function registerLocalTypes(ns) {
+    const versioned = versionedRegistrar(ns, 'local');
+    ns.register({
+        name: 'qvac-state',
+        enum: ['RESUME', 'WAKEUP', 'PRESUSPEND', 'SUSPEND']
+    });
+    versioned('config', [
+        { name: 'key', type: 'string', required: true },
+        { name: 'value', type: 'json' }
+    ]);
+    versioned('mesh-session', [
+        { name: 'deviceId', type: 'buffer', required: true },
+        { name: 'meshCreator', type: 'bool' },
+        { name: 'meshKey', type: 'buffer' },
+        { name: 'meshSeed', type: 'buffer' }
+    ]);
+    versioned('mesh-history', [
+        { name: 'key', type: 'buffer', required: true },
+        { name: 'seed', type: 'buffer', required: true },
+        { name: 'creator', type: 'bool' },
+        { name: 'writerSeed', type: 'string' }
+    ]);
+    versioned('device', [
+        { name: 'publicKey', type: 'buffer', required: true },
+        { name: 'name', type: 'string', required: true },
+        { name: 'capabilityProfile', type: '@local/capability-profile', required: true },
+        { name: 'recommendedModelName', type: 'string', required: true },
+        { name: 'platform', type: 'string' }
+    ]);
+    versioned('app-config', [
+        { name: 'id', type: 'string', required: true },
+        { name: 'activeAgentId', type: 'string' },
+        { name: 'activeChatId', type: 'string' },
+        { name: 'thinkingEnabled', type: 'bool' },
+        { name: 'ctxSize', type: 'uint' },
+        { name: 'lastModelName', type: 'string' },
+        { name: 'onboardingCompleted', type: 'bool' },
+        { name: 'delegation', type: 'json' },
+        { name: 'pausedModels', type: 'string', array: true }
+    ]);
+    ns.register({
+        name: 'model-download-phase',
+        enum: ['queued', 'downloading', 'paused', 'error'],
+        strings: true
+    });
+    versioned('model-download', [
+        { name: 'name', type: 'string', required: true },
+        { name: 'phase', type: '@local/model-download-phase', required: true },
+        { name: 'percentage', type: 'uint' },
+        { name: 'error', type: 'string' },
+        { name: 'updatedAt', type: 'uint', required: true },
+        { name: 'downloaded', type: 'uint' },
+        { name: 'total', type: 'uint' },
+        { name: 'bytesPerSecond', type: 'uint' }
+    ]);
+    versioned('custom-model', [
+        { name: 'name', type: 'string', required: true },
+        { name: 'src', type: 'string', required: true },
+        { name: 'mmprojSrc', type: 'string' },
+        { name: 'supportsTools', type: 'bool' },
+        { name: 'supportsThinking', type: 'bool' },
+        { name: 'supportsVision', type: 'bool' },
+        { name: 'expectedSize', type: 'uint' },
+        { name: 'createdAt', type: 'uint', required: true }
+    ]);
+    versioned('identity', [
+        { name: 'id', type: 'string', required: true },
+        { name: 'publicKey', type: 'buffer', required: true },
+        { name: 'proof', type: 'buffer', required: true },
+        { name: 'createdAt', type: 'uint', required: true }
+    ]);
+    versioned('membership', [
+        { name: 'id', type: 'string', required: true },
+        { name: 'memberId', type: 'fixed32', required: true },
+        { name: 'proof', type: 'buffer', required: true },
+        { name: 'attestedAt', type: 'uint', required: true }
+    ]);
+    versioned('chat-notify', [
+        { name: 'chatId', type: 'string', required: true },
+        { name: 'ackedThrough', type: 'uint', required: true }
+    ]);
+    versioned('model-notify', [
+        { name: 'name', type: 'string', required: true },
+        { name: 'transferId', type: 'string', required: true },
+        { name: 'notificationId', type: 'string' },
+        { name: 'completedAt', type: 'uint' },
+        { name: 'acknowledged', type: 'bool' },
+        { name: 'transferred', type: 'bool' }
+    ]);
+    versioned('mesh-departure', [
+        { name: 'key', type: 'buffer', required: true },
+        { name: 'seed', type: 'buffer', required: true },
+        { name: 'creator', type: 'bool' },
+        { name: 'writerSeed', type: 'string' }
+    ]);
+    ns.register({ name: 'capability-profile', enum: CAPABILITY_PROFILES, strings: true });
+}
+export function registerLocalCollections(dbns) {
+    dbns.collections.register({ name: 'config', schema: '@local/config', key: ['key'] });
+    dbns.collections.register({
+        name: 'mesh-session',
+        schema: '@local/mesh-session',
+        key: ['deviceId']
+    });
+    dbns.collections.register({
+        name: 'mesh-history',
+        schema: '@local/mesh-history',
+        key: ['key']
+    });
+    dbns.collections.register({ name: 'device', schema: '@local/device', key: ['publicKey'] });
+    dbns.collections.register({ name: 'app-config', schema: '@local/app-config', key: ['id'] });
+    dbns.collections.register({
+        name: 'model-download',
+        schema: '@local/model-download',
+        key: ['name']
+    });
+    dbns.collections.register({
+        name: 'custom-model',
+        schema: '@local/custom-model',
+        key: ['name']
+    });
+    dbns.collections.register({ name: 'identity', schema: '@local/identity', key: ['id'] });
+    dbns.collections.register({ name: 'membership', schema: '@local/membership', key: ['id'] });
+    dbns.collections.register({ name: 'chat-notify', schema: '@local/chat-notify', key: ['chatId'] });
+    dbns.collections.register({ name: 'model-notify', schema: '@local/model-notify', key: ['name'] });
+    dbns.collections.register({
+        name: 'mesh-departure',
+        schema: '@local/mesh-departure',
+        key: ['key']
+    });
+}

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

@@ -0,0 +1,22 @@
+export { APPROVAL_STATUSES, CHUNK_PAYLOAD_FIELDS, CHUNK_TYPES, RUN_STATES, registerContentTypes, type ChunkPayloadField, type ChunkType } from './content.ts';
+export declare const INDEXING_STATES: string[];
+export declare const CAPABILITY_PROFILES: string[];
+export declare const APP_CHANNELS: string[];
+export declare const RAG_SOURCE_EXCERPT_CHARS = 280;
+export declare const MAX_RAG_SOURCES_PER_CHUNK = 1024;
+export declare const MAX_RAG_SOURCE_NOTICE_CHARS = 1024;
+export declare const MAX_RAG_SOURCE_URL_CHARS = 2048;
+export declare function ragSourcesWithinBounds(content: {
+    readonly sources: ReadonlyArray<{
+        readonly excerpt: string;
+        readonly url?: string | null;
+    }>;
+    readonly notice?: string | null;
+} | null | undefined): boolean;
+export declare const MAX_TOOL_CONFIGS_BYTES: number;
+export declare function toolConfigsWithinBounds(settings: unknown): boolean;
+export declare const MAX_TOOL_ACTIVITY_ARGS_BYTES: number;
+export declare function capToolActivityArguments(args: unknown): unknown;
+export declare function registerQvacTypes(ns: any): void;
+export declare function registerQvacCollections(dbns: any, helpersPath: string): void;
+export declare function registerQvacDispatch(ds: any): void;