@qvac/core 0.0.0 → 0.1.1

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/helpers.d.ts

@@ -0,0 +1,28 @@
+// Hand-written declarations for the generated schema/helpers.js. assistant's own
+// tsconfig uses allowJs + checkJs:false, but strict consumers (app-runtime,
+// mobile) without allowJs need these types to import the module without TS7016.
+// The `*Map` helpers are hyperdb map-reduce emitters: they return an array of
+// plain record rows (e.g. `[{ chatId, type, seq }]`), never a Map. Rows stay
+// `Record<string, any>` to match the previously-inferred shape and keep existing
+// .ts callers permissive.
+export function chunkTypeOrdinal(type: string): number
+export function chunksByTypeMap(record: any): ReadonlyArray<Record<string, any>>
+export function activeAgentsMap(record: any): ReadonlyArray<Record<string, any>>
+export function activeChatsMap(record: any): ReadonlyArray<Record<string, any>>
+export function activeChatsByAgentMap(record: any): ReadonlyArray<Record<string, any>>
+export function activeChatGroupsMap(record: any): ReadonlyArray<Record<string, any>>
+export function activeKnowledgeByChatMap(record: any): ReadonlyArray<Record<string, any>>
+export function activeToolConfigsByAgentMap(record: any): ReadonlyArray<Record<string, any>>
+export function toolActivityByAgentMap(record: any): ReadonlyArray<Record<string, any>>
+export function runRequestsMap(record: any): ReadonlyArray<Record<string, any>>
+export const MEDIA_KINDS: readonly ['audio', 'image', 'video', 'other']
+export const AUDIO_EXTENSIONS: readonly string[]
+export function mediaKindOf(
+  mimeType?: string,
+  fileName?: string
+): 'audio' | 'image' | 'video' | 'other'
+export function mediaKindOrdinal(kind: string): number
+export function attachmentsByMediaKindMap(record: any): ReadonlyArray<Record<string, any>>
+export function attachmentsByMediaKindOriginMap(record: any): ReadonlyArray<Record<string, any>>
+export function historyChunksMap(record: any): ReadonlyArray<Record<string, any>>
+export function liveWritersByMostRecentMap(record: any): ReadonlyArray<Record<string, any>>

package/dist-lib/schema/helpers.js

@@ -0,0 +1,176 @@
+// imported by the generated spec at runtime (dbns.require embeds a relative path) — stays plain .js
+const historyChunkTypes = ['user-message', 'run-request', 'content', 'attachment', 'compaction']
+
+// index keys hold the ordinal, kept in sync by hand with CHUNK_TYPES order in content.ts
+export function chunkTypeOrdinal(type) {
+  switch (type) {
+    case 'user-message':
+      return 1
+    case 'content':
+      return 2
+    case 'thinking':
+      return 3
+    case 'tool-call':
+      return 4
+    case 'tool-result':
+      return 5
+    case 'attachment':
+      return 6
+    case 'approval-request':
+      return 7
+    case 'run-status':
+      return 8
+    case 'run-request':
+      return 9
+    case 'sources':
+      return 10
+    case 'compaction':
+      return 11
+    default:
+      throw new Error('Unknown chunk type: ' + type)
+  }
+}
+
+export function chunksByTypeMap(record) {
+  if (record.type === undefined) return []
+  return [{ chatId: record.chatId, type: chunkTypeOrdinal(record.type), seq: record.seq }]
+}
+
+export function activeAgentsMap(record) {
+  if (record.deletedAt) return []
+  return [{ createdAt: record.createdAt }]
+}
+
+export function activeChatsMap(record) {
+  if (record.deletedAt) return []
+  return [{ createdAt: record.createdAt }]
+}
+
+export function activeChatGroupsMap(record) {
+  if (record.deletedAt) return []
+  return [{ createdAt: record.createdAt }]
+}
+
+export function activeChatsByAgentMap(record) {
+  if (record.deletedAt) return []
+  return [{ agentId: record.agentId, createdAt: record.createdAt }]
+}
+
+export function activeKnowledgeByChatMap(record) {
+  if (record.deletedAt || !record.chatId) return []
+  return [{ chatId: record.chatId }]
+}
+
+export function activeToolConfigsByAgentMap(record) {
+  if (record.deletedAt) return []
+  return [{ agentId: record.agentId }]
+}
+
+// append-only tool-call log keyed by agent then apply-assigned seq — one range query lists an
+// agent's whole activity across every chat and device, in a peer-consistent order (seq, not wall
+// clock). No tombstone filter: activity is immutable history.
+export function toolActivityByAgentMap(record) {
+  if (!record.agentId) return []
+  return [{ agentId: record.agentId, seq: record.seq }]
+}
+
+export function runRequestsMap(record) {
+  if (record.type !== 'run-request') return []
+  return [{ chatId: record.chatId, seq: record.seq }]
+}
+
+// media kinds for the attachments-by-media-kind index. The ordinal rides in the key as a plain
+// uint (same pattern as chunksByTypeMap); MEDIA_KINDS is the name↔ordinal source of truth, and
+// the wire media-kind enum in engine.ts is registered from this same array so the two never drift.
+export const MEDIA_KINDS = ['audio', 'image', 'video', 'other']
+
+// `.mp4` is deliberately audio, not video: audio recordings ship in the mp4 container and are
+// transcribed from their audio track (parity with isAudioAttachment). audio-attachment.ts derives
+// isAudioAttachment from mediaKindOf, so this list is the one source of truth for "what is audio".
+export const AUDIO_EXTENSIONS = ['.m4a', '.mp3', '.wav', '.ogg', '.flac', '.aac', '.mp4']
+const IMAGE_EXTENSIONS = [
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.webp',
+  '.bmp',
+  '.svg',
+  '.heic',
+  '.heif',
+  '.avif'
+]
+const VIDEO_EXTENSIONS = ['.mov', '.webm', '.mkv', '.avi', '.m4v']
+
+function endsWithAny(name, extensions) {
+  return extensions.some((extension) => name.endsWith(extension))
+}
+
+// classify an attachment by mime first, then filename extension. Broad by design so a generated
+// `audio/wav` and a user `recording.m4a` both land under 'audio'.
+export function mediaKindOf(mimeType, fileName) {
+  const mime = (mimeType || '').toLowerCase()
+  const name = (fileName || '').toLowerCase()
+  if (mime.startsWith('audio/') || endsWithAny(name, AUDIO_EXTENSIONS)) return 'audio'
+  if (mime.startsWith('image/') || endsWithAny(name, IMAGE_EXTENSIONS)) return 'image'
+  if (mime.startsWith('video/') || endsWithAny(name, VIDEO_EXTENSIONS)) return 'video'
+  return 'other'
+}
+
+export function mediaKindOrdinal(kind) {
+  const ordinal = MEDIA_KINDS.indexOf(kind)
+  if (ordinal === -1) throw new Error('Unknown media kind: ' + kind)
+  return ordinal + 1
+}
+
+// every non-deleted attachment chunk, keyed by media kind then createdAt — NOT chatId-prefixed,
+// so one range query lists all audio (uploaded or generated) across every chat in the mesh. Drops
+// non-attachment chunks and tombstoned attachments so a gallery never scans-and-filters.
+export function attachmentsByMediaKindMap(record) {
+  if (record.type !== 'attachment') return []
+  const attachment = record.attachment
+  if (!attachment || attachment.deletedAt) return []
+  return [
+    {
+      mediaKind: mediaKindOrdinal(mediaKindOf(attachment.mimeType, attachment.fileName)),
+      createdAt: record.createdAt
+    }
+  ]
+}
+
+// generated tool output always carries a runId; a user upload never does (attachment-knowledge.ts
+// only routes runId-less uploads to knowledge). So runId presence IS the origin, kept out of the
+// key as a plain 0/1 uint the way mediaKind is.
+function attachmentGenerated(record) {
+  return record.runId ? 1 : 0
+}
+
+// the same attachments as attachmentsByMediaKindMap, but with origin (generated vs uploaded) folded
+// into the key so "only generated audio" / "only uploaded audio" is a range query, not a post-filter.
+export function attachmentsByMediaKindOriginMap(record) {
+  if (record.type !== 'attachment') return []
+  const attachment = record.attachment
+  if (!attachment || attachment.deletedAt) return []
+  return [
+    {
+      mediaKind: mediaKindOrdinal(mediaKindOf(attachment.mimeType, attachment.fileName)),
+      generated: attachmentGenerated(record),
+      createdAt: record.createdAt
+    }
+  ]
+}
+
+export function devicesByWriterKeyMap(record) {
+  if (!record.writerKey) return []
+  return [{ writerKey: record.writerKey }]
+}
+
+export function historyChunksMap(record) {
+  if (!historyChunkTypes.includes(record.type)) return []
+  return [{ chatId: record.chatId, seq: record.seq }]
+}
+
+export function liveWritersByMostRecentMap(record) {
+  if (record.revoked) return []
+  return [{ clock: record.clock }]
+}

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;