@qvac/core 0.1.0 → 0.1.1

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

@@ -0,0 +1,5 @@
+// these builder packages ship no types — blank ambient modules, schema-authoring-time only
+declare module 'hrpc'
+declare module 'hyperdispatch'
+declare module 'hyperschema'
+declare module 'hyperdb/builder'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Peer-to-peer AI across your devices",
   "exports": {
@@ -69,6 +69,10 @@
       "default": "./dist-lib/client.js"
     },
     "./capabilities": "./dist-lib/spec/capabilities.d.ts",
+    "./wire-codec": {
+      "types": "./dist-lib/spec/hrpc/messages.d.ts",
+      "default": "./dist-lib/spec/hrpc/messages.js"
+    },
     "./log": {
       "types": "./dist-lib/lib/log.d.ts",
       "default": "./dist-lib/lib/log.js"