@lapis-notes/api 0.1.0

package/dist/storage/task-projection.d.ts

@@ -0,0 +1,152 @@
+import { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID, type IndexFieldDefinition, type IndexQuery } from "./index-projection";
+export declare const TASK_PROJECTION_VERSION = 3;
+export declare const TASK_OCCURRENCE_PROJECTION_VERSION = 1;
+export { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID };
+export declare const TASK_PROJECTION_FIELDS: Record<string, IndexFieldDefinition>;
+export declare const TASK_OCCURRENCE_PROJECTION_FIELDS: Record<string, IndexFieldDefinition>;
+export type AppDatabaseTaskKind = "task" | "task-list";
+export type AppDatabaseTaskStatus = "open" | "completed" | "canceled" | "active" | "archived";
+export type AppDatabaseTaskStartKind = "anytime" | "someday" | "date";
+export type AppDatabaseTaskPlanKind = "anytime" | "morning" | "afternoon" | "evening" | "time";
+export type AppDatabaseEffectiveOccurrenceState = "current" | "overdue" | "future" | "exhausted" | "paused" | "unsupported";
+export interface AppDatabaseTaskRepeat {
+    start?: string;
+    rrule: string;
+    anchor: "schedule" | "completion";
+    missed: "carry" | "skip";
+    rdate?: string[];
+    exdate?: string[];
+    resetChecklist?: boolean;
+    paused?: boolean;
+    pausedSince?: string;
+    pauseRanges?: Array<{
+        start: string;
+        end: string;
+    }>;
+    lastCompletedAt?: string;
+    completionCount?: number;
+}
+export type AppDatabaseTaskTracking = {
+    type: "boolean";
+} | {
+    type: "count";
+    unit: string;
+    target?: number;
+} | {
+    type: "duration";
+    target?: string;
+} | {
+    type: "number";
+    unit: string;
+    target?: number;
+};
+export type AppDatabaseLinkKind = "reference" | "task-entry" | "list-entry" | "navigation-item";
+export type AppDatabaseTaskStructuralKind = "task-entry" | "list-entry";
+export interface AppDatabaseTaskStructuralEntry {
+    sourceDocumentId: string;
+    sourceDocumentPath: string;
+    targetDocumentId: string;
+    targetDocumentPath: string;
+    kind: AppDatabaseTaskStructuralKind;
+    headingPath: string[];
+    headingLevel: number | null;
+    headingText: string | null;
+    runId: string;
+    positionInRun: number;
+    sourceStart: number;
+    sourceEnd: number;
+    authoredLabel: string;
+    authoredHref: string;
+}
+export interface AppDatabaseTaskRun {
+    id: string;
+    documentId: string;
+    documentPath: string;
+    headingPath: string[];
+    headingLevel: number | null;
+    headingText: string | null;
+    listDepth: number;
+    startOffset: number;
+    endOffset: number;
+    entryCount: number;
+}
+export interface AppDatabaseTaskStructureDiagnostic {
+    code: string;
+    message: string;
+    sourceStart?: number;
+    sourceEnd?: number;
+    target?: string;
+}
+export interface AppDatabaseTaskStructure {
+    version: number;
+    sourceHash: string;
+    entries: AppDatabaseTaskStructuralEntry[];
+    runs: AppDatabaseTaskRun[];
+    diagnostics: AppDatabaseTaskStructureDiagnostic[];
+}
+export type AppDatabaseTaskView = "inbox" | "today" | "anytime" | "upcoming" | "someday" | "completed" | "review";
+export interface AppDatabaseTaskRecord {
+    documentPath: string;
+    documentId: string;
+    kind: AppDatabaseTaskKind;
+    title: string;
+    status: AppDatabaseTaskStatus;
+    inbox: boolean;
+    startKind: AppDatabaseTaskStartKind;
+    startDate?: string | null;
+    planDate?: string | null;
+    planKind?: AppDatabaseTaskPlanKind | null;
+    planTime?: string | null;
+    durationMinutes?: number | null;
+    deadline?: string | null;
+    completedAt?: string | null;
+    repeat?: AppDatabaseTaskRepeat | null;
+    tracking?: AppDatabaseTaskTracking | null;
+    effectiveOccurrenceDate?: string | null;
+    effectiveOccurrenceState?: AppDatabaseEffectiveOccurrenceState | null;
+    effectiveForDate?: string | null;
+    /** @deprecated Read compatibility for task projection v2 rows. */
+    repeatStrategy?: string | null;
+    /** @deprecated Read compatibility for task projection v2 rows. */
+    repeatFrequency?: string | null;
+    /** @deprecated Read compatibility for task projection v2 rows. */
+    repeatInterval?: number | null;
+    /** @deprecated Read compatibility for task projection v2 rows. */
+    repeatAnchor?: string | null;
+    checklistTotal: number;
+    checklistCompleted: number;
+    commentCount: number;
+    structure?: AppDatabaseTaskStructure | null;
+    projectionVersion: number;
+}
+export type AppDatabaseTaskOccurrenceOutcome = "pending" | "completed" | "missed";
+/** Disposable observation parsed from one exact daily-note list item range. */
+export interface AppDatabaseTaskOccurrenceRecord {
+    observationId: string;
+    taskId: string;
+    taskPath: string;
+    dailyDocumentPath: string;
+    occurrenceDate: string;
+    outcome: AppDatabaseTaskOccurrenceOutcome;
+    trackingKind: AppDatabaseTaskTracking["type"];
+    value?: number | null;
+    unit?: string | null;
+    durationMinutes?: number | null;
+    sourceStart: number;
+    sourceEnd: number;
+    projectionVersion: number;
+}
+export interface AppDatabaseTaskQuery {
+    view?: AppDatabaseTaskView;
+    today?: string;
+    documentId?: string;
+    documentPath?: string;
+    kind?: AppDatabaseTaskKind;
+    limit?: number;
+}
+export interface AppDatabaseTaskChildQuery {
+    sourcePath: string;
+    kind?: AppDatabaseLinkKind;
+}
+export declare function matchesTaskQuery(row: AppDatabaseTaskRecord, query: AppDatabaseTaskQuery): boolean;
+export declare function taskQueryToIndexQuery(query?: AppDatabaseTaskQuery): IndexQuery;

package/dist/storage/task-projection.js

@@ -0,0 +1,154 @@
+import { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID, and, eq, gt, isNull, lt, lte, or, } from "./index-projection";
+export const TASK_PROJECTION_VERSION = 3;
+export const TASK_OCCURRENCE_PROJECTION_VERSION = 1;
+export { PUBLIC_TASKS_PROJECTION_ID, PUBLIC_TASK_OCCURRENCES_PROJECTION_ID };
+export const TASK_PROJECTION_FIELDS = {
+    documentPath: { type: "path", indexed: true, sortable: true },
+    documentId: { type: "string", indexed: true, unique: true },
+    kind: { type: "string", indexed: true },
+    title: { type: "string", indexed: true, sortable: true },
+    status: { type: "string", indexed: true, sortable: true },
+    inbox: { type: "boolean", indexed: true },
+    startKind: { type: "string", indexed: true },
+    startDate: { type: "date", indexed: true, sortable: true },
+    planDate: { type: "date", indexed: true, sortable: true },
+    planKind: { type: "string", indexed: true },
+    planTime: { type: "string", indexed: true, sortable: true },
+    durationMinutes: { type: "number", indexed: true, sortable: true },
+    deadline: { type: "date", indexed: true, sortable: true },
+    completedAt: { type: "string", indexed: true },
+    repeat: { type: "json" },
+    repeatStart: { type: "date", indexed: true, sortable: true },
+    repeatRRule: { type: "string", indexed: true },
+    repeatAnchor: { type: "string", indexed: true },
+    repeatMissed: { type: "string", indexed: true },
+    repeatPaused: { type: "boolean", indexed: true },
+    repeatPausedSince: { type: "date", indexed: true, sortable: true },
+    tracking: { type: "json" },
+    effectiveOccurrenceDate: { type: "date", indexed: true, sortable: true },
+    effectiveOccurrenceState: { type: "string", indexed: true, sortable: true },
+    effectiveForDate: { type: "date", indexed: true, sortable: true },
+    checklistTotal: { type: "number" },
+    checklistCompleted: { type: "number" },
+    commentCount: { type: "number", indexed: true },
+    structure: { type: "json" },
+};
+export const TASK_OCCURRENCE_PROJECTION_FIELDS = {
+    observationId: { type: "string", indexed: true, unique: true },
+    taskId: { type: "string", indexed: true, sortable: true },
+    taskPath: { type: "path", indexed: true },
+    dailyDocumentPath: { type: "path", indexed: true },
+    occurrenceDate: { type: "date", indexed: true, sortable: true },
+    outcome: { type: "string", indexed: true, sortable: true },
+    trackingKind: { type: "string", indexed: true },
+    value: { type: "number", indexed: true, sortable: true },
+    unit: { type: "string", indexed: true },
+    durationMinutes: { type: "number", indexed: true, sortable: true },
+    sourceStart: { type: "number" },
+    sourceEnd: { type: "number" },
+};
+function isOpenTask(row) {
+    return row.kind === "task" && row.status === "open";
+}
+function startIsActionable(row, today) {
+    if (row.startKind === "anytime")
+        return true;
+    if (row.startKind === "date") {
+        return Boolean(row.startDate && row.startDate <= today);
+    }
+    return false;
+}
+function hasEffectiveOccurrence(row) {
+    return Boolean(row.effectiveOccurrenceState);
+}
+export function matchesTaskQuery(row, query) {
+    if (query.documentPath && row.documentPath !== query.documentPath)
+        return false;
+    if (query.documentId && row.documentId !== query.documentId)
+        return false;
+    if (query.kind && row.kind !== query.kind)
+        return false;
+    if (!query.view)
+        return true;
+    const today = query.today ?? new Date().toISOString().slice(0, 10);
+    switch (query.view) {
+        case "inbox":
+            return isOpenTask(row) && row.inbox;
+        case "today":
+            return (isOpenTask(row) &&
+                (((row.effectiveOccurrenceState === "current" ||
+                    row.effectiveOccurrenceState === "unsupported") &&
+                    row.effectiveOccurrenceDate === today) ||
+                    (!hasEffectiveOccurrence(row) &&
+                        Boolean(row.planDate) &&
+                        row.planDate <= today) ||
+                    (Boolean(row.deadline) && row.deadline <= today)));
+        case "anytime":
+            return isOpenTask(row) && startIsActionable(row, today) && !row.planDate;
+        case "upcoming":
+            return (isOpenTask(row) &&
+                ((row.effectiveOccurrenceState === "future" &&
+                    Boolean(row.effectiveOccurrenceDate)) ||
+                    (!hasEffectiveOccurrence(row) &&
+                        Boolean(row.startDate) &&
+                        row.startDate > today) ||
+                    (!hasEffectiveOccurrence(row) &&
+                        Boolean(row.planDate) &&
+                        row.planDate > today) ||
+                    (Boolean(row.deadline) && row.deadline > today)));
+        case "someday":
+            return isOpenTask(row) && row.startKind === "someday";
+        case "completed":
+            return row.status === "completed";
+        case "review":
+            return (isOpenTask(row) &&
+                (row.effectiveOccurrenceState === "overdue" ||
+                    (!hasEffectiveOccurrence(row) &&
+                        Boolean(row.planDate) &&
+                        row.planDate < today)));
+        default:
+            return false;
+    }
+}
+export function taskQueryToIndexQuery(query = {}) {
+    const clauses = [];
+    if (query.documentPath)
+        clauses.push(eq("documentPath", query.documentPath));
+    if (query.documentId)
+        clauses.push(eq("documentId", query.documentId));
+    if (query.kind)
+        clauses.push(eq("kind", query.kind));
+    if (query.view) {
+        const today = query.today ?? new Date().toISOString().slice(0, 10);
+        const openTask = and(eq("kind", "task"), eq("status", "open"));
+        switch (query.view) {
+            case "inbox":
+                clauses.push(and(openTask, eq("inbox", true)));
+                break;
+            case "today":
+                clauses.push(and(openTask, or(and(or(eq("effectiveOccurrenceState", "current"), eq("effectiveOccurrenceState", "unsupported")), eq("effectiveOccurrenceDate", today)), and(isNull("effectiveOccurrenceState"), lte("planDate", today)), lte("deadline", today))));
+                break;
+            case "anytime":
+                clauses.push(and(openTask, isNull("planDate"), or(eq("startKind", "anytime"), and(eq("startKind", "date"), lte("startDate", today)))));
+                break;
+            case "upcoming":
+                clauses.push(and(openTask, or(and(eq("effectiveOccurrenceState", "future"), gt("effectiveOccurrenceDate", today)), and(isNull("effectiveOccurrenceState"), gt("startDate", today)), and(isNull("effectiveOccurrenceState"), gt("planDate", today)), gt("deadline", today))));
+                break;
+            case "someday":
+                clauses.push(and(openTask, eq("startKind", "someday")));
+                break;
+            case "completed":
+                clauses.push(eq("status", "completed"));
+                break;
+            case "review":
+                clauses.push(and(openTask, or(eq("effectiveOccurrenceState", "overdue"), and(isNull("effectiveOccurrenceState"), lt("planDate", today)))));
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        where: clauses.length === 1 ? clauses[0] : clauses.length ? and(...clauses) : undefined,
+        limit: query.limit,
+    };
+}

package/dist/storage/turso-app-database.d.ts

@@ -0,0 +1,150 @@
+import { type AppDatabase, type AppDatabaseChangeListener, type AppDatabaseDescriptor, type AppDatabaseFileHistory, type AppDatabaseIndexedFile, type AppDatabaseIndexedFileManifestPage, type AppDatabaseIndexedFileManifestQuery, type AppDatabaseIndexedMetadataPage, type AppDatabaseIndexedMetadataPageQuery, type AppDatabaseIndexedMetadataQuery, type AppDatabaseIndexedMetadataRow, type AppDatabaseKind, type AppDatabaseLinkRecord, type AppDatabaseMetadataFacetQuery, type AppDatabaseMetadataFacetRow, type AppDatabaseMetadataLinkQuery, type AppDatabaseMemoryCandidateInput, type AppDatabaseMemoryCandidateQuery, type AppDatabaseMemoryCandidateResult, type AppDatabaseMemoryJobClaimInput, type AppDatabaseMemoryJobRecord, type AppDatabaseMemoryJobUpdateInput, type AppDatabaseMemoryRecallSignalRecord, type AppDatabaseMemorySourceRecord, type AppDatabaseNotebookState, type AppDatabaseNotificationRecord, type AppDatabaseOpenContext, type AppDatabaseProvider, type AppDatabaseSearchIndexStats, type AppDatabaseSearchOptions, type AppDatabaseSearchResult, type AppDatabaseStoreFileHistoryRevisionInput, type AppDatabaseStoreFileHistoryRevisionResult, type MetadataCacheSnapshot, type SearchDocumentRecord, type SearchDocumentManifestPage, type SearchDocumentManifestQuery, type SearchEmbeddingProviderConfig } from "./app-database";
+import { type IndexProjectionDefinitionRecord, type IndexQuery, type IndexQueryResult, type IndexRelatedQuery, type MarkProjectionSourceErrorInput, type ReplaceProjectionSourceInput } from "./index-projection";
+import type { AppDatabaseTaskChildQuery, AppDatabaseTaskQuery, AppDatabaseTaskRecord } from "./task-projection";
+import { type SearchEmbeddingRuntimeStatus } from "./search-embedding-provider";
+export interface TursoStatementInput {
+    sql: string;
+    args?: unknown[] | Record<string, unknown>;
+}
+export interface TursoConnection {
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...args: unknown[]): Promise<unknown>;
+    get<T extends Record<string, unknown>>(sql: string, ...args: unknown[]): Promise<T | undefined>;
+    all<T extends Record<string, unknown>>(sql: string, ...args: unknown[]): Promise<T[]>;
+    batch(statements: Array<string | TursoStatementInput>, options?: string): Promise<unknown>;
+    close(): Promise<void>;
+}
+export type TursoConnectionFactory = () => Promise<TursoConnection>;
+export interface TursoAppDatabaseOptions {
+    kind: Extract<AppDatabaseKind, "turso-native" | "turso-wasm">;
+    providerId?: string;
+    transport: AppDatabaseDescriptor["transport"];
+    role?: AppDatabaseDescriptor["role"];
+    crossTabCoordination?: boolean;
+    connectionFactory: TursoConnectionFactory;
+}
+export declare const TURSO_APP_DATABASE_SCHEMA_VERSION = 5;
+export declare const TURSO_APP_DATABASE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS schema_meta (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS app_state (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  state_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS app_meta (\n  key TEXT PRIMARY KEY,\n  value_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS app_revision (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  revision INTEGER NOT NULL\n);\nCREATE TABLE IF NOT EXISTS app_changes (\n  revision INTEGER PRIMARY KEY,\n  domains_json TEXT NOT NULL,\n  paths_json TEXT NOT NULL,\n  renamed_json TEXT,\n  committed_at INTEGER NOT NULL\n);\nCREATE TABLE IF NOT EXISTS files (\n  path TEXT PRIMARY KEY,\n  normalized_path TEXT NOT NULL,\n  extension TEXT NOT NULL,\n  mtime INTEGER NOT NULL,\n  size INTEGER NOT NULL,\n  hash TEXT NOT NULL,\n  indexed INTEGER NOT NULL,\n  deleted INTEGER NOT NULL\n);\nCREATE INDEX IF NOT EXISTS files_manifest_idx\n  ON files(deleted, indexed, path);\nCREATE INDEX IF NOT EXISTS files_extension_path_idx\n  ON files(extension, deleted, indexed, path);\nCREATE TABLE IF NOT EXISTS metadata (\n  path TEXT PRIMARY KEY,\n  hash TEXT NOT NULL,\n  parser_version TEXT NOT NULL,\n  data_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS links (\n  source_path TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (source_path, ordinal)\n);\nCREATE TABLE IF NOT EXISTS tags (\n  path TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (path, ordinal)\n);\nCREATE TABLE IF NOT EXISTS properties (\n  path TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (path, ordinal)\n);\nCREATE TABLE IF NOT EXISTS metadata_links (\n  source_path TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  normalized_target TEXT NOT NULL,\n  resolved_target_path TEXT,\n  resolution_state TEXT NOT NULL,\n  link_type TEXT NOT NULL,\n  link_kind TEXT,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (source_path, ordinal)\n);\nCREATE INDEX IF NOT EXISTS metadata_links_incoming_idx\n  ON metadata_links(resolved_target_path, source_path, ordinal);\nCREATE INDEX IF NOT EXISTS metadata_links_unresolved_idx\n  ON metadata_links(resolution_state, normalized_target, source_path);\nCREATE TABLE IF NOT EXISTS metadata_tags (\n  path TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  tag TEXT NOT NULL,\n  normalized_tag TEXT NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (path, ordinal)\n);\nCREATE INDEX IF NOT EXISTS metadata_tags_exact_idx\n  ON metadata_tags(normalized_tag, path);\nCREATE TABLE IF NOT EXISTS metadata_tag_ancestors (\n  path TEXT NOT NULL,\n  tag_ordinal INTEGER NOT NULL,\n  ancestor TEXT NOT NULL,\n  depth INTEGER NOT NULL,\n  PRIMARY KEY (path, tag_ordinal, ancestor)\n);\nCREATE INDEX IF NOT EXISTS metadata_tag_ancestors_idx\n  ON metadata_tag_ancestors(ancestor, path);\nCREATE TABLE IF NOT EXISTS metadata_properties (\n  path TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  name TEXT NOT NULL,\n  normalized_name TEXT NOT NULL,\n  inferred_type TEXT NOT NULL,\n  declared_type TEXT,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (path, ordinal)\n);\nCREATE INDEX IF NOT EXISTS metadata_properties_name_idx\n  ON metadata_properties(normalized_name, path);\nCREATE TABLE IF NOT EXISTS metadata_property_values (\n  path TEXT NOT NULL,\n  property_ordinal INTEGER NOT NULL,\n  value_ordinal INTEGER NOT NULL,\n  property_name TEXT NOT NULL,\n  property_path TEXT NOT NULL,\n  normalized_property_path TEXT NOT NULL,\n  value_type TEXT NOT NULL,\n  text_value TEXT,\n  number_value REAL,\n  boolean_value INTEGER,\n  date_value TEXT,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (path, property_ordinal, value_ordinal, property_path)\n);\nCREATE INDEX IF NOT EXISTS metadata_property_text_idx\n  ON metadata_property_values(property_name, text_value, path);\nCREATE INDEX IF NOT EXISTS metadata_property_number_idx\n  ON metadata_property_values(property_name, number_value, path);\nCREATE INDEX IF NOT EXISTS metadata_property_boolean_idx\n  ON metadata_property_values(property_name, boolean_value, path);\nCREATE INDEX IF NOT EXISTS metadata_property_date_idx\n  ON metadata_property_values(property_name, date_value, path);\nCREATE TABLE IF NOT EXISTS tasks (\n  document_path TEXT PRIMARY KEY,\n  document_id TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  title TEXT NOT NULL,\n  status TEXT NOT NULL,\n  inbox INTEGER NOT NULL DEFAULT 0,\n  start_kind TEXT NOT NULL,\n  start_date TEXT,\n  plan_date TEXT,\n  plan_kind TEXT,\n  plan_time TEXT,\n  duration_minutes INTEGER,\n  deadline TEXT,\n  completed_at TEXT,\n  repeat_strategy TEXT,\n  repeat_frequency TEXT,\n  repeat_interval INTEGER,\n  repeat_anchor TEXT,\n  checklist_total INTEGER NOT NULL DEFAULT 0,\n  checklist_completed INTEGER NOT NULL DEFAULT 0,\n  comment_count INTEGER NOT NULL DEFAULT 0,\n  projection_version INTEGER NOT NULL\n);\nCREATE TABLE IF NOT EXISTS task_records (\n  document_path TEXT PRIMARY KEY,\n  data_json TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS tasks_open_plan ON tasks(status, plan_date);\nCREATE INDEX IF NOT EXISTS tasks_open_deadline ON tasks(status, deadline);\nCREATE INDEX IF NOT EXISTS tasks_open_start ON tasks(status, start_kind, start_date);\nCREATE INDEX IF NOT EXISTS tasks_inbox ON tasks(status, inbox);\nCREATE TABLE IF NOT EXISTS index_projections (\n  projection_id TEXT PRIMARY KEY,\n  owner_plugin_id TEXT NOT NULL,\n  schema_version INTEGER NOT NULL,\n  config_hash TEXT NOT NULL,\n  visibility TEXT NOT NULL,\n  fields_json TEXT NOT NULL,\n  active INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\nCREATE TABLE IF NOT EXISTS index_projection_sources (\n  projection_id TEXT NOT NULL,\n  source_path TEXT NOT NULL,\n  source_hash TEXT NOT NULL,\n  schema_version INTEGER NOT NULL,\n  config_hash TEXT NOT NULL,\n  status TEXT NOT NULL,\n  error TEXT,\n  indexed_at INTEGER NOT NULL,\n  PRIMARY KEY (projection_id, source_path)\n);\nCREATE TABLE IF NOT EXISTS index_projection_rows (\n  projection_id TEXT NOT NULL,\n  row_id TEXT NOT NULL,\n  source_path TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  ordinal INTEGER NOT NULL DEFAULT 0,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (projection_id, row_id)\n);\nCREATE INDEX IF NOT EXISTS index_projection_rows_source\n  ON index_projection_rows(projection_id, source_path);\nCREATE TABLE IF NOT EXISTS index_projection_values (\n  projection_id TEXT NOT NULL,\n  row_id TEXT NOT NULL,\n  field TEXT NOT NULL,\n  ordinal INTEGER NOT NULL DEFAULT 0,\n  value_type TEXT NOT NULL,\n  text_value TEXT,\n  number_value REAL,\n  boolean_value INTEGER,\n  date_value TEXT,\n  datetime_value INTEGER,\n  PRIMARY KEY (projection_id, row_id, field, ordinal)\n);\nCREATE TABLE IF NOT EXISTS index_projection_edges (\n  projection_id TEXT NOT NULL,\n  source_row_id TEXT NOT NULL,\n  relation TEXT NOT NULL,\n  target_projection_id TEXT,\n  target_row_id TEXT,\n  target_path TEXT,\n  target_text TEXT,\n  ordinal INTEGER NOT NULL,\n  data_json TEXT,\n  PRIMARY KEY (projection_id, source_row_id, relation, ordinal)\n);\nCREATE TABLE IF NOT EXISTS history_files (\n  file_id TEXT PRIMARY KEY,\n  data_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS history_file_paths (\n  path TEXT PRIMARY KEY,\n  file_id TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS history_revisions (\n  file_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (file_id, ordinal)\n);\nCREATE TABLE IF NOT EXISTS notifications (\n  id TEXT PRIMARY KEY,\n  data_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS search_docs (\n  path TEXT PRIMARY KEY,\n  source_provider_id TEXT,\n  metadata_hash TEXT,\n  provider_version TEXT,\n  projection_signature TEXT,\n  source_mtime INTEGER,\n  source_size INTEGER,\n  name TEXT NOT NULL,\n  extension TEXT NOT NULL,\n  checksum TEXT NOT NULL,\n  content TEXT NOT NULL,\n  tags TEXT NOT NULL,\n  metadata_text TEXT NOT NULL,\n  data_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS search_chunks (\n  id TEXT PRIMARY KEY,\n  path TEXT NOT NULL,\n  text TEXT NOT NULL,\n  embedding_json TEXT,\n  embedding BLOB\n);\nCREATE INDEX IF NOT EXISTS search_chunks_path_idx ON search_chunks(path);\nCREATE TABLE IF NOT EXISTS memory_source_state (\n  source_key TEXT PRIMARY KEY,\n  source_path TEXT NOT NULL,\n  source_hash TEXT NOT NULL,\n  status TEXT NOT NULL,\n  indexed_at INTEGER NOT NULL,\n  data_json TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS memory_candidates (\n  id TEXT PRIMARY KEY,\n  scope_kind TEXT NOT NULL,\n  scope_path TEXT NOT NULL,\n  state TEXT NOT NULL,\n  last_seen_at INTEGER NOT NULL,\n  data_json TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS memory_candidates_scope_state\n  ON memory_candidates(scope_kind, scope_path, state, last_seen_at DESC);\nCREATE TABLE IF NOT EXISTS memory_candidate_origins (\n  candidate_id TEXT NOT NULL,\n  conversation_id TEXT NOT NULL,\n  entry_id TEXT NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (candidate_id, conversation_id, entry_id)\n);\nCREATE INDEX IF NOT EXISTS memory_candidate_origins_conversation\n  ON memory_candidate_origins(conversation_id, candidate_id);\nCREATE TABLE IF NOT EXISTS memory_recall_signals (\n  target_ref TEXT NOT NULL,\n  query_fingerprint TEXT NOT NULL,\n  day TEXT NOT NULL,\n  best_score REAL NOT NULL,\n  hit_count INTEGER NOT NULL,\n  data_json TEXT NOT NULL,\n  PRIMARY KEY (target_ref, query_fingerprint, day)\n);\nCREATE TABLE IF NOT EXISTS memory_jobs (\n  id TEXT PRIMARY KEY,\n  scope_key TEXT NOT NULL,\n  status TEXT NOT NULL,\n  lease_until INTEGER,\n  created_at INTEGER NOT NULL,\n  data_json TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS memory_jobs_scope_created\n  ON memory_jobs(scope_key, created_at DESC);\n";
+export declare function tursoWasmDatabasePath(vaultId: string): string;
+export declare class TursoAppDatabase implements AppDatabase {
+    readonly vaultId: string;
+    private readonly options;
+    readonly kind: Extract<AppDatabaseKind, "turso-native" | "turso-wasm">;
+    private connection;
+    private opened;
+    private nativeFullTextSearch;
+    private nativeVectorSearch;
+    private searchEmbeddingProviderConfig;
+    private searchEmbeddingProvider;
+    private currentRevision;
+    private commitQueue;
+    private readonly changeListeners;
+    constructor(vaultId: string, options: TursoAppDatabaseOptions);
+    get descriptor(): AppDatabaseDescriptor;
+    open(): Promise<void>;
+    migrate(): Promise<void>;
+    close(): Promise<void>;
+    beginSearchIndexingBatch(): Promise<void>;
+    endSearchIndexingBatch(): Promise<void>;
+    configureSearchEmbeddingProvider(provider: SearchEmbeddingProviderConfig | null): Promise<void>;
+    getSearchEmbeddingProvider(): Promise<SearchEmbeddingProviderConfig | null>;
+    getSearchEmbeddingRuntimeStatus(): Promise<SearchEmbeddingRuntimeStatus | null>;
+    getSearchIndexStats(): Promise<AppDatabaseSearchIndexStats>;
+    getMeta<T = unknown>(key: string): Promise<T | undefined>;
+    setMeta(key: string, value: unknown): Promise<void>;
+    getNotebookState(sourcePath: string): Promise<AppDatabaseNotebookState | undefined>;
+    setNotebookState(sourcePath: string, state: AppDatabaseNotebookState): Promise<void>;
+    deleteNotebookState(sourcePath: string): Promise<void>;
+    loadMetadataSnapshot(): Promise<MetadataCacheSnapshot | null>;
+    saveMetadataSnapshot(snapshot: MetadataCacheSnapshot): Promise<void>;
+    getFileHistory(path: string): Promise<AppDatabaseFileHistory | null>;
+    storeFileHistoryRevision(input: AppDatabaseStoreFileHistoryRevisionInput): Promise<AppDatabaseStoreFileHistoryRevisionResult>;
+    listNotifications(): Promise<AppDatabaseNotificationRecord[]>;
+    upsertNotification(record: AppDatabaseNotificationRecord): Promise<void>;
+    markNotificationRead(id: string): Promise<void>;
+    clearNotification(id: string): Promise<void>;
+    clearAllNotifications(): Promise<void>;
+    getMemorySourceState(sourceKey: string): Promise<AppDatabaseMemorySourceRecord | undefined>;
+    listMemorySourceStates(): Promise<AppDatabaseMemorySourceRecord[]>;
+    upsertMemorySourceState(record: AppDatabaseMemorySourceRecord): Promise<void>;
+    deleteMemorySourceState(sourceKey: string): Promise<void>;
+    upsertMemoryCandidate(input: AppDatabaseMemoryCandidateInput): Promise<void>;
+    queryMemoryCandidates(query?: AppDatabaseMemoryCandidateQuery): Promise<AppDatabaseMemoryCandidateResult[]>;
+    deleteMemoryCandidatesByConversation(conversationId: string): Promise<void>;
+    recordMemoryRecallSignal(record: AppDatabaseMemoryRecallSignalRecord): Promise<void>;
+    listMemoryRecallSignals(targetRef?: string): Promise<AppDatabaseMemoryRecallSignalRecord[]>;
+    claimMemoryJob(input: AppDatabaseMemoryJobClaimInput): Promise<AppDatabaseMemoryJobRecord | null>;
+    updateMemoryJob(input: AppDatabaseMemoryJobUpdateInput): Promise<AppDatabaseMemoryJobRecord | null>;
+    listMemoryJobs(scopeKey?: string): Promise<AppDatabaseMemoryJobRecord[]>;
+    clearMemoryDerivedState(): Promise<void>;
+    getChangeRevision(): Promise<number>;
+    subscribeToChanges(listener: AppDatabaseChangeListener): () => void;
+    upsertIndexedFile(record: AppDatabaseIndexedFile): Promise<void>;
+    getIndexedFile(path: string): Promise<AppDatabaseIndexedMetadataRow | undefined>;
+    listIndexedFileManifest(query?: AppDatabaseIndexedFileManifestQuery): Promise<AppDatabaseIndexedFileManifestPage>;
+    queryIndexedMetadata(query?: AppDatabaseIndexedMetadataQuery): Promise<AppDatabaseIndexedMetadataRow[]>;
+    queryIndexedMetadataPage(input?: AppDatabaseIndexedMetadataPageQuery): Promise<AppDatabaseIndexedMetadataPage>;
+    queryMetadataFacets(query: AppDatabaseMetadataFacetQuery): Promise<AppDatabaseMetadataFacetRow[]>;
+    queryMetadataLinks(query: AppDatabaseMetadataLinkQuery): Promise<AppDatabaseLinkRecord[]>;
+    deleteIndexedFile(path: string): Promise<void>;
+    renameIndexedFile(oldPath: string, newPath: string): Promise<void>;
+    upsertSearchDocument(document: SearchDocumentRecord): Promise<void>;
+    deleteSearchDocument(path: string): Promise<void>;
+    getSearchDocument(path: string): Promise<SearchDocumentRecord | undefined>;
+    listSearchDocumentManifest(query?: SearchDocumentManifestQuery): Promise<SearchDocumentManifestPage>;
+    listSearchDocuments(): Promise<SearchDocumentRecord[]>;
+    rebuildSearchIndex(): Promise<void>;
+    searchDocuments(query: string, options?: AppDatabaseSearchOptions): Promise<AppDatabaseSearchResult[]>;
+    searchDocumentPaths(query: string, options?: AppDatabaseSearchOptions): Promise<string[]>;
+    private queryAllSearchPaths;
+    private queryLexicalPaths;
+    private queryVectorPaths;
+    upsertTaskProjection(record: AppDatabaseTaskRecord): Promise<void>;
+    deleteTaskProjection(path: string): Promise<void>;
+    queryTasks(query?: AppDatabaseTaskQuery): Promise<AppDatabaseTaskRecord[]>;
+    getTaskRow(lookup: {
+        path?: string;
+        id?: string;
+    }): Promise<AppDatabaseTaskRecord | undefined>;
+    listChildLinks(query: AppDatabaseTaskChildQuery): Promise<AppDatabaseLinkRecord[]>;
+    listTaskDescendants(path: string): Promise<AppDatabaseTaskRecord[]>;
+    registerProjectionDefinition(definition: IndexProjectionDefinitionRecord): Promise<void>;
+    unregisterProjectionDefinition(projectionId: string): Promise<void>;
+    replaceProjectionSource(input: ReplaceProjectionSourceInput): Promise<void>;
+    markProjectionSourceError(input: MarkProjectionSourceErrorInput): Promise<void>;
+    deleteProjectionSource(projectionId: string, sourcePath: string, writerPluginId?: string): Promise<void>;
+    queryProjection<T = Record<string, unknown>>(projectionId: string, query?: IndexQuery, readerPluginId?: string): Promise<IndexQueryResult<T>>;
+    getProjectionRow<T = Record<string, unknown>>(projectionId: string, rowId: string, readerPluginId?: string): Promise<T | null>;
+    queryRelated<T = Record<string, unknown>>(query: IndexRelatedQuery, readerPluginId?: string): Promise<IndexQueryResult<T>>;
+    private commit;
+    private commitImmediately;
+    private updateNotification;
+    private fileRecordFromRow;
+    private readIndexedFiles;
+    private readIndexedFile;
+    private compileMetadataPathQuery;
+    private compilePropertyFilter;
+    private compilePathPrefixes;
+    private deletePathStatements;
+    private deleteMetadataPathStatements;
+    private searchDocumentStatements;
+    private prepareSearchDocument;
+    private evaluateSearchDocumentsForPaths;
+    private safeEmbedQuery;
+    private deleteProjectionSourceStatements;
+    private getProjectionDefinition;
+    private getProjectionSources;
+    private ensureTasksProjectionDefinition;
+    private backfillNormalizedMetadata;
+    private captureMigrationInvariants;
+    private validateMigration;
+    private ensureMetadataPropertyPathSchema;
+    private requireConnection;
+}
+export declare function canUseTursoWasmDatabase(): boolean;
+export declare function createTursoWasmConnection(path: string): Promise<TursoConnection>;
+export declare class TursoWasmAppDatabaseProvider implements AppDatabaseProvider {
+    readonly id = "turso-wasm-local";
+    canOpen(context: AppDatabaseOpenContext): boolean;
+    open(context: AppDatabaseOpenContext): Promise<AppDatabase>;
+}