@seedprotocol/sdk 0.4.1 → 0.4.3

package/dist/Db-DX08SxS9.js

@@ -0,0 +1,1521 @@
+import { p as BaseDb, s as BaseFileManager } from './json-I3vJhXo8.js';
+import debug from 'debug';
+import { sql } from 'drizzle-orm';
+import { readMigrationFiles } from 'drizzle-orm/migrator';
+import { drizzle } from 'drizzle-orm/sqlite-proxy';
+import { migrate } from 'drizzle-orm/sqlite-proxy/migrator';
+import { s as schema } from './index-r45w9hEq.js';
+import { SQLocalDrizzle } from 'sqlocal/drizzle';
+import { Observable, distinctUntilChanged } from 'rxjs';
+import 'xstate';
+import 'pluralize';
+import 'lodash-es';
+import 'drizzle-orm/casing';
+import '@sinclair/typebox';
+import 'arweave';
+import 'eventemitter3';
+import 'drizzle-orm/sqlite-core';
+import 'ethers';
+import 'nanoid';
+import 'nanoid-dictionary';
+
+// This file embeds the drizzle migration files as strings for browser runtime
+// These files are copied from src/db/drizzle at build time
+// Individual migration SQL files
+const migrationSql_0000_married_malice = `CREATE TABLE \`appState\` (
+	\`key\` text,
+	\`value\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`appState_key_unique\` ON \`appState\` (\`key\`);--> statement-breakpoint
+CREATE TABLE \`config\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`key\` text NOT NULL,
+	\`text\` text,
+	\`json\` text,
+	\`blob\` blob
+);
+--> statement-breakpoint
+CREATE TABLE \`metadata\` (
+	\`local_id\` text,
+	\`uid\` text,
+	\`property_name\` text,
+	\`property_value\` text,
+	\`schema_uid\` text,
+	\`model_type\` text,
+	\`seed_local_id\` text,
+	\`seed_uid\` text,
+	\`version_local_id\` text,
+	\`version_uid\` text,
+	\`eas_data_type\` text,
+	\`ref_value_type\` text,
+	\`ref_schema_uid\` text,
+	\`ref_seed_type\` text,
+	\`ref_resolved_value\` text,
+	\`ref_resolved_display_value\` text,
+	\`local_storage_dir\` text,
+	\`attestation_raw\` text,
+	\`attestation_created_at\` integer,
+	\`content_hash\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`metadata_local_id_unique\` ON \`metadata\` (\`local_id\`);--> statement-breakpoint
+CREATE TABLE \`models\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`name\` text NOT NULL,
+	\`schema_file_id\` text
+);
+--> statement-breakpoint
+CREATE TABLE \`properties\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`name\` text NOT NULL,
+	\`data_type\` text NOT NULL,
+	\`model_id\` integer NOT NULL,
+	\`ref_model_id\` integer,
+	\`ref_value_type\` text,
+	\`schema_file_id\` text,
+	FOREIGN KEY (\`model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (\`ref_model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`unique_name_model_id\` ON \`properties\` (\`name\`,\`model_id\`);--> statement-breakpoint
+CREATE TABLE \`model_schemas\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`model_id\` integer,
+	\`schema_id\` integer,
+	FOREIGN KEY (\`model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (\`schema_id\`) REFERENCES \`schemas\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE TABLE \`model_uids\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`uid\` text NOT NULL,
+	\`model_id\` integer NOT NULL,
+	FOREIGN KEY (\`model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`model_uids_model_id_unique\` ON \`model_uids\` (\`model_id\`);--> statement-breakpoint
+CREATE TABLE \`property_uids\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`uid\` text NOT NULL,
+	\`property_id\` integer NOT NULL,
+	FOREIGN KEY (\`property_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`property_uids_property_id_unique\` ON \`property_uids\` (\`property_id\`);--> statement-breakpoint
+CREATE TABLE \`schemas\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`name\` text NOT NULL,
+	\`version\` integer NOT NULL,
+	\`schema_file_id\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE TABLE \`seeds\` (
+	\`local_id\` text,
+	\`uid\` text,
+	\`schema_uid\` text,
+	\`type\` text,
+	\`attestation_raw\` text,
+	\`attestation_created_at\` integer,
+	\`created_at\` integer,
+	\`updated_at\` integer,
+	\`_marked_for_deletion\` integer
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`seeds_local_id_unique\` ON \`seeds\` (\`local_id\`);--> statement-breakpoint
+CREATE TABLE \`versions\` (
+	\`local_id\` text,
+	\`uid\` text,
+	\`seed_local_id\` text,
+	\`seed_uid\` text,
+	\`seed_type\` text,
+	\`note\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer,
+	\`attestation_created_at\` integer,
+	\`attestation_raw\` text
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`versions_local_id_unique\` ON \`versions\` (\`local_id\`);`;
+const migrationSql_0001_sweet_bruce_banner = `ALTER TABLE \`schemas\` ADD \`schema_data\` text;--> statement-breakpoint
+ALTER TABLE \`schemas\` ADD \`is_draft\` integer;`;
+const migrationSql_0002_bitter_proudstar = `CREATE UNIQUE INDEX \`unique_schema_file_id\` ON \`models\` (\`schema_file_id\`);--> statement-breakpoint
+CREATE UNIQUE INDEX \`unique_property_schema_file_id\` ON \`properties\` (\`schema_file_id\`);--> statement-breakpoint
+CREATE UNIQUE INDEX \`unique_schema_schema_file_id\` ON \`schemas\` (\`schema_file_id\`);`;
+const migrationSql_0003_cultured_senator_kelly = `ALTER TABLE \`models\` ADD \`is_edited\` integer;--> statement-breakpoint
+ALTER TABLE \`properties\` ADD \`is_edited\` integer;--> statement-breakpoint
+ALTER TABLE \`schemas\` ADD \`is_edited\` integer;`;
+// Journal JSON file
+const journalJson = `{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1765976502903,
+      "tag": "0000_married_malice",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1766010851770,
+      "tag": "0001_sweet_bruce_banner",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1767621120087,
+      "tag": "0002_bitter_proudstar",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1768415440282,
+      "tag": "0003_cultured_senator_kelly",
+      "breakpoints": true
+    }
+  ]
+}`;
+// Snapshot JSON file - this is large, so we'll import it dynamically if needed
+// For now, we'll read it from the actual file if ?raw works, otherwise we'll need to embed it
+const snapshotJson = `{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "0e6a6a99-2eb1-4b1d-815b-3d45dcae04a1",
+  "prevId": "49b9a020-1b1c-4107-85ee-a5f8a958f1a2",
+  "tables": {
+    "appState": {
+      "name": "appState",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "appState_key_unique": {
+          "name": "appState_key_unique",
+          "columns": [
+            "key"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "config": {
+      "name": "config",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "json": {
+          "name": "json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "blob": {
+          "name": "blob",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "metadata": {
+      "name": "metadata",
+      "columns": {
+        "local_id": {
+          "name": "local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "property_name": {
+          "name": "property_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "property_value": {
+          "name": "property_value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_uid": {
+          "name": "schema_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model_type": {
+          "name": "model_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_local_id": {
+          "name": "seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_uid": {
+          "name": "seed_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "version_local_id": {
+          "name": "version_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "version_uid": {
+          "name": "version_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "eas_data_type": {
+          "name": "eas_data_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_value_type": {
+          "name": "ref_value_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_schema_uid": {
+          "name": "ref_schema_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_seed_type": {
+          "name": "ref_seed_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_resolved_value": {
+          "name": "ref_resolved_value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_resolved_display_value": {
+          "name": "ref_resolved_display_value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "local_storage_dir": {
+          "name": "local_storage_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_raw": {
+          "name": "attestation_raw",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_created_at": {
+          "name": "attestation_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "metadata_local_id_unique": {
+          "name": "metadata_local_id_unique",
+          "columns": [
+            "local_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "models": {
+      "name": "models",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_file_id": {
+          "name": "schema_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_edited": {
+          "name": "is_edited",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "unique_schema_file_id": {
+          "name": "unique_schema_file_id",
+          "columns": [
+            "schema_file_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "properties": {
+      "name": "properties",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "data_type": {
+          "name": "data_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model_id": {
+          "name": "model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ref_model_id": {
+          "name": "ref_model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_value_type": {
+          "name": "ref_value_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_file_id": {
+          "name": "schema_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_edited": {
+          "name": "is_edited",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "unique_name_model_id": {
+          "name": "unique_name_model_id",
+          "columns": [
+            "name",
+            "model_id"
+          ],
+          "isUnique": true
+        },
+        "unique_property_schema_file_id": {
+          "name": "unique_property_schema_file_id",
+          "columns": [
+            "schema_file_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "properties_model_id_models_id_fk": {
+          "name": "properties_model_id_models_id_fk",
+          "tableFrom": "properties",
+          "tableTo": "models",
+          "columnsFrom": [
+            "model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "properties_ref_model_id_models_id_fk": {
+          "name": "properties_ref_model_id_models_id_fk",
+          "tableFrom": "properties",
+          "tableTo": "models",
+          "columnsFrom": [
+            "ref_model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "model_schemas": {
+      "name": "model_schemas",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "model_id": {
+          "name": "model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_id": {
+          "name": "schema_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "model_schemas_model_id_models_id_fk": {
+          "name": "model_schemas_model_id_models_id_fk",
+          "tableFrom": "model_schemas",
+          "tableTo": "models",
+          "columnsFrom": [
+            "model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "model_schemas_schema_id_schemas_id_fk": {
+          "name": "model_schemas_schema_id_schemas_id_fk",
+          "tableFrom": "model_schemas",
+          "tableTo": "schemas",
+          "columnsFrom": [
+            "schema_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "model_uids": {
+      "name": "model_uids",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model_id": {
+          "name": "model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "model_uids_model_id_unique": {
+          "name": "model_uids_model_id_unique",
+          "columns": [
+            "model_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "model_uids_model_id_models_id_fk": {
+          "name": "model_uids_model_id_models_id_fk",
+          "tableFrom": "model_uids",
+          "tableTo": "models",
+          "columnsFrom": [
+            "model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "property_uids": {
+      "name": "property_uids",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "property_id": {
+          "name": "property_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "property_uids_property_id_unique": {
+          "name": "property_uids_property_id_unique",
+          "columns": [
+            "property_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "property_uids_property_id_models_id_fk": {
+          "name": "property_uids_property_id_models_id_fk",
+          "tableFrom": "property_uids",
+          "tableTo": "models",
+          "columnsFrom": [
+            "property_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "schemas": {
+      "name": "schemas",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_file_id": {
+          "name": "schema_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_data": {
+          "name": "schema_data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_draft": {
+          "name": "is_draft",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_edited": {
+          "name": "is_edited",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "unique_schema_schema_file_id": {
+          "name": "unique_schema_schema_file_id",
+          "columns": [
+            "schema_file_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "seeds": {
+      "name": "seeds",
+      "columns": {
+        "local_id": {
+          "name": "local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_uid": {
+          "name": "schema_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_raw": {
+          "name": "attestation_raw",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_created_at": {
+          "name": "attestation_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "_marked_for_deletion": {
+          "name": "_marked_for_deletion",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "seeds_local_id_unique": {
+          "name": "seeds_local_id_unique",
+          "columns": [
+            "local_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "versions": {
+      "name": "versions",
+      "columns": {
+        "local_id": {
+          "name": "local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_local_id": {
+          "name": "seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_uid": {
+          "name": "seed_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_type": {
+          "name": "seed_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_created_at": {
+          "name": "attestation_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_raw": {
+          "name": "attestation_raw",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "versions_local_id_unique": {
+          "name": "versions_local_id_unique",
+          "columns": [
+            "local_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}`;
+
+var drizzleFiles = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  journalJson: journalJson,
+  migrationSql_0000_married_malice: migrationSql_0000_married_malice,
+  migrationSql_0001_sweet_bruce_banner: migrationSql_0001_sweet_bruce_banner,
+  migrationSql_0002_bitter_proudstar: migrationSql_0002_bitter_proudstar,
+  migrationSql_0003_cultured_senator_kelly: migrationSql_0003_cultured_senator_kelly,
+  snapshotJson: snapshotJson
+});
+
+const logger = debug('seedSdk:browser:db:Db');
+class Db extends BaseDb {
+    constructor() {
+        super();
+    }
+    static getAppDb() {
+        return this.appDb;
+    }
+    static isAppDbReady() {
+        return !!this.appDb;
+    }
+    static async prepareDb(filesDir) {
+        logger('[Db.prepareDb] preparing database');
+        this.filesDir = filesDir;
+        try {
+            // Copy drizzle migration files from src/db/drizzle to filesDir/db
+            await this.copyDrizzleFiles(filesDir);
+            // Ensure meta directory exists
+            const metaDirPath = `${filesDir}/db/meta`;
+            await BaseFileManager.createDirIfNotExists(metaDirPath);
+            // Ensure _journal.json file exists in meta directory
+            const journalFilePath = `${metaDirPath}/_journal.json`;
+            const journalExists = await BaseFileManager.pathExists(journalFilePath);
+            if (!journalExists) {
+                await BaseFileManager.saveFile(journalFilePath, JSON.stringify({
+                    version: 1,
+                    dialect: 'sqlite',
+                    entries: [],
+                }, null, 2));
+            }
+            // Wait for journal file to be fully written before proceeding with migration
+            // This is critical in browser/OPFS where writes may not be immediately readable
+            logger('[Db.prepareDb] waiting for journal file to be fully written...');
+            await BaseFileManager.waitForFileWithContent(journalFilePath, 100, 5000);
+            logger('[Db.prepareDb] journal file is ready');
+            // Initialize SQLocalDrizzle with reactive: true to enable reactive queries
+            const sqlocalDrizzle = new SQLocalDrizzle({
+                databasePath: `${this.filesDir}/db/seed.db`,
+                reactive: true // Enable reactive queries
+            });
+            const { driver, batchDriver } = sqlocalDrizzle;
+            // Store SQLocalDrizzle instance for reactive queries
+            this.sqlocalInstance = sqlocalDrizzle;
+            this.appDb = drizzle(driver, batchDriver, {
+                schema,
+            });
+            logger('[Db.prepareDb] database prepared');
+            await this.migrate();
+            return this.appDb;
+        }
+        catch (error) {
+            logger('[Db.prepareDb] error', JSON.stringify(error));
+            throw error;
+        }
+    }
+    // static async prepareDb(filesDir: string) {
+    //   console.log('prepareDb', filesDir)
+    //   if (Db.sqliteWasmClient) {
+    //     return this.dbId
+    //   }
+    //   this.filesDir = filesDir
+    //   this.pathToDb = `${filesDir}/db/${DB_NAME_APP}.db`
+    //   if (typeof document === 'undefined') {
+    //     return
+    //   }
+    //   let promiser
+    //   try {
+    //       let sqlite3Worker1Promiser
+    //       const sqliteWasm = await import('@sqlite.org/sqlite-wasm')
+    //       if (sqliteWasm && sqliteWasm.sqlite3Worker1Promiser) {
+    //         sqlite3Worker1Promiser = sqliteWasm.sqlite3Worker1Promiser
+    //       }
+    //       if (!sqlite3Worker1Promiser && window.sqlite3Worker1Promiser) {
+    //         sqlite3Worker1Promiser = window.sqlite3Worker1Promiser
+    //       }
+    //       if (!sqlite3Worker1Promiser) {
+    //         throw new Error('Failed to load sqlite3Worker1Promiser')
+    //       }
+    //       promiser = await new Promise<(event: string, config: Record<string, unknown>) => Promise<any>>((resolve) => {
+    //         const _promiser = sqlite3Worker1Promiser({
+    //           onready: () => {
+    //             resolve(_promiser);
+    //           },
+    //         });
+    //       }).catch((error) => {
+    //         console.error('Error from sqlite proxy server: ', JSON.stringify(error))
+    //       });
+    //   } catch ( e ) {
+    //     console.error('Error from sqlite proxy server: ', JSON.stringify(e))
+    //   }
+    //   if (!promiser) {
+    //     throw new Error('Failed to create promiser')
+    //   }
+    //   this.sqliteWasmClient = promiser
+    //   const responseGet = await this.sqliteWasmClient('config-get', {});
+    //   logger('[Db.prepareDb] Running SQLite3 version', responseGet.result.version.libVersion);
+    //   const responseOpen = await this.sqliteWasmClient('open', {
+    //     filename: `file:${filesDir}/db/${DB_NAME_APP}.db?vfs=opfs`,
+    //   });
+    //   const { dbId } = responseOpen;
+    //   logger(
+    //     '[Db.prepareDb] OPFS is available, created persisted database at',
+    //     responseOpen.result.filename.replace(/^file:(.*?)\?vfs=opfs/, '$1'),
+    //   );
+    //   logger('[Db.prepareDb] dbId', dbId)
+    //   this.dbId = dbId
+    //   await this.migrate()
+    // }
+    static async connectToDb(filesDir) {
+        return this.dbId;
+    }
+    static async copyDrizzleFiles(filesDir) {
+        logger('[Db.copyDrizzleFiles] copying drizzle migration files');
+        try {
+            // Ensure db directory exists
+            const dbDirPath = `${filesDir}/db`;
+            await BaseFileManager.createDirIfNotExists(dbDirPath);
+            // Ensure meta directory exists
+            const metaDirPath = `${dbDirPath}/meta`;
+            await BaseFileManager.createDirIfNotExists(metaDirPath);
+            // Parse journal JSON to get all migration entries
+            const journal = JSON.parse(journalJson);
+            const entries = journal.entries || [];
+            if (entries.length === 0) {
+                logger('[Db.copyDrizzleFiles] no migration entries found in journal');
+                return;
+            }
+            // Copy each migration SQL file (always overwrite to ensure they're up-to-date)
+            // Each migration is exported as a separate variable (e.g., migrationSql_0000_married_malice)
+            for (let i = 0; i < entries.length; i++) {
+                const entry = entries[i];
+                const tag = entry.tag; // e.g., "0000_married_malice"
+                const migrationFileName = `${tag}.sql`;
+                const migrationPath = `${dbDirPath}/${migrationFileName}`;
+                // Get the SQL for this migration from the exported variable
+                const migrationVarName = `migrationSql_${tag}`;
+                const migrationContent = drizzleFiles[migrationVarName];
+                if (!migrationContent) {
+                    logger(`[Db.copyDrizzleFiles] ERROR: No migration content found for ${migrationFileName} (variable: ${migrationVarName})`);
+                    throw new Error(`No migration content found for ${migrationFileName}. Expected variable: ${migrationVarName}`);
+                }
+                await BaseFileManager.saveFile(migrationPath, migrationContent.trim());
+                logger(`[Db.copyDrizzleFiles] copied/updated migration SQL file: ${migrationFileName}`);
+            }
+            // Copy journal JSON file (always overwrite to ensure it's up-to-date with all migrations)
+            const journalPath = `${metaDirPath}/_journal.json`;
+            await BaseFileManager.saveFile(journalPath, journalJson);
+            logger('[Db.copyDrizzleFiles] copied/updated journal JSON file');
+            // Copy snapshot JSON file (use the latest snapshot based on the highest idx in journal)
+            // Snapshot files are named like: 0000_snapshot.json, 0001_snapshot.json, etc.
+            // The tag format is like "0000_married_malice", so we extract the numeric prefix
+            const latestEntry = entries[entries.length - 1];
+            const tagPrefixMatch = latestEntry.tag.match(/^(\d+_)/);
+            const tagPrefix = tagPrefixMatch ? tagPrefixMatch[1] : '0000_';
+            const snapshotFileName = `${tagPrefix}snapshot.json`;
+            const snapshotPath = `${metaDirPath}/${snapshotFileName}`;
+            // Always overwrite snapshot to ensure it's up-to-date
+            await BaseFileManager.saveFile(snapshotPath, snapshotJson);
+            logger(`[Db.copyDrizzleFiles] copied/updated snapshot JSON file: ${snapshotFileName}`);
+            logger('[Db.copyDrizzleFiles] drizzle files copied successfully');
+        }
+        catch (error) {
+            logger('[Db.copyDrizzleFiles] error copying drizzle files', error);
+            // Don't throw - the files might already exist or migration might work without them
+            // The migration will fail later if the files are truly needed
+        }
+    }
+    static async migrate() {
+        if (!this.appDb) {
+            throw new Error('Database not prepared');
+        }
+        const pathToDbDir = `${this.filesDir}/db`;
+        try {
+            logger('[Db.migrate] calling readMigrationFiles');
+            const migrations = readMigrationFiles({
+                migrationsFolder: pathToDbDir,
+            });
+            logger('[Db.migrate] migrations', migrations);
+            await migrate(this.appDb, async (queriesToRun) => {
+                logger('queriesToRun', queriesToRun);
+                for (const query of queriesToRun) {
+                    logger('query', query);
+                    await this.appDb?.run(sql.raw(query));
+                }
+            }, {
+                migrationsFolder: pathToDbDir,
+            });
+            logger('[Db.migrate] migrations completed');
+        }
+        catch (error) {
+            logger('[Db.migrate] error', JSON.stringify(error));
+            throw error;
+        }
+    }
+    // static async migrate(): Promise<void> {
+    //   const schemaGlobString = `${BROWSER_FS_TOP_DIR}/schema/*`
+    //   const pathToDbDir = `${this.filesDir}/db`
+    //   const dbName = DB_NAME_APP
+    //   logger('[Db.migrate] running migrations')
+    //   const drizzleDb = drizzle(
+    //     async (sql, params,) => {
+    //       try {
+    //         logger(
+    //           `executing sql`,
+    //           sql,
+    //         )
+    //         const finalResult = await this.exec(sql, params)
+    //         // logger(`finalResult with method: ${method}`, finalResult)
+    //         // Drizzle always waits for {rows: string[][]} or {rows: string[]} for the return value.
+    //         // When the method is get,  you should return a value as {rows: string[]}.
+    //         // Otherwise, you should return {rows: string[][]}.
+    //         return { rows: finalResult }
+    //       } catch (e: any) {
+    //         console.error('Error from sqlite proxy server: ', JSON.stringify(e))
+    //         return { rows: [] }
+    //       }
+    //     },
+    //     {
+    //       schema,
+    //       // logger: true,
+    //     },
+    //   )
+    //   try {
+    //     const zenfs = await BaseFileManager.getFs()
+    //     logger('[Db.migrate] calling readMigrationFiles')
+    //     const migrations = readMigrationFiles({
+    //       migrationsFolder: pathToDbDir,
+    //     })
+    //     logger('[Db.migrate] migrations', migrations)
+    //     if (migrations.length > 0) {
+    //       const incomingMigrationHashes = migrations.map(
+    //         (migration) => migration.hash,
+    //       )
+    //       let existingMigrationHashes
+    //       let rows = []
+    //       try {
+    //         const queryMigrationsTable = await drizzleDb.run(
+    //           sql.raw(
+    //             `SELECT name 
+    //              FROM sqlite_master 
+    //              WHERE type='table' 
+    //              AND name='__drizzle_migrations';`,
+    //           ),
+    //         )
+    //         logger('queryMigrationsTable', queryMigrationsTable)
+    //         if (queryMigrationsTable && queryMigrationsTable.rows && queryMigrationsTable.rows.length > 0) {
+    //           const query = await drizzleDb.run(
+    //             sql.raw(
+    //               `SELECT hash, created_at
+    //                FROM main.__drizzle_migrations;`,
+    //             ),
+    //           )
+    //           rows = query.rows
+    //         }
+    //       } catch (e) {
+    //         rows = []
+    //       }
+    //       if (rows && rows.length > 0) {
+    //         existingMigrationHashes = rows.map((row) => row[0])
+    //       }
+    //       if (existingMigrationHashes) {
+    //         let shouldRebuildDb = false
+    //         for (const existingHash of existingMigrationHashes) {
+    //           if (!incomingMigrationHashes.includes(existingHash)) {
+    //             shouldRebuildDb = true
+    //             break
+    //           }
+    //         }
+    //         if (shouldRebuildDb) {
+    //           await zenfs.promises.unlink(`${pathToDbDir}/${dbName}.db`)
+    //         }
+    //       }
+    //     }
+    //     logger('[Db.migrate] running migrations')
+    //     await drizzleMigrate(
+    //       drizzleDb,
+    //       async (queriesToRun) => {
+    //         // logger('queriesToRun', queriesToRun)
+    //         for (const query of queriesToRun) {
+    //           // logger('query', query)
+    //           await drizzleDb.run(sql.raw(query))
+    //         }
+    //       },
+    //       {
+    //         migrationsFolder: pathToDbDir,
+    //       },
+    //     )
+    //   } catch (error) {
+    //     logger('[Db.migrate] error', JSON.stringify(error))
+    //     // await BaseFileManager.waitForFile(`${pathToDbDir}/meta/_journal.json`)
+    //     // const journalExists = await BaseFileManager.pathExists(
+    //     //   `${pathToDbDir}/meta/_journal.json`,
+    //     // )
+    //     // if (journalExists) {
+    //     //   await this.migrate(pathToDbDir, dbName,)
+    //     // }
+    //     // if (!journalExists) {
+    //     //   throw new Error('Failed to migrate database')
+    //     // }
+    //   }
+    //   this.appDb = drizzleDb
+    //   // Old code for migrating the database
+    //   // const createTempTableQuery = await appDb.run(
+    //   //   sql.raw(
+    //   //     `CREATE TEMP TABLE IF NOT EXISTS temp_last_inserted_id (id INTEGER, table TEXT);`,
+    //   //   ),
+    //   // )
+    //   //
+    //   // logger(
+    //   //   '[db/actors] [migrate] createTempTableQuery',
+    //   //   createTempTableQuery,
+    //   // )
+    //   // const triggersQuery = await appDb.run(
+    //   //   sql.raw(
+    //   //     `SELECT name
+    //   //      FROM main.sqlite_master
+    //   //      WHERE type = 'trigger';`,
+    //   //   ),
+    //   // )
+    //   //
+    //   // logger('[db/actors] [migrate] triggersQuery', triggersQuery)
+    //   //
+    //   // const triggers = triggersQuery.rows.map((row) => row[0])
+    //   //
+    //   // const tablesQuery = await appDb.run(
+    //   //   sql.raw(
+    //   //     `SELECT name
+    //   //      FROM main.sqlite_master
+    //   //      WHERE type = 'table';`,
+    //   //   ),
+    //   // )
+    //   //
+    //   // logger('[db/actors] [migrate] tablesQuery', tablesQuery)
+    //   //
+    //   // const tableNames = tablesQuery.rows.map((row) => row[0])
+    //   // logger('[db/actors] [migrate] tableNames', tableNames)
+    //   // for (const tableName of tableNames) {
+    //   //   const triggerName = `after_insert_${tableName}`
+    //   //   if (triggers.includes(triggerName)) {
+    //   //     continue
+    //   //   }
+    //   //           const createTriggerQuery = await appDb.run(
+    //   //             sql.raw(
+    //   //               `CREATE TRIGGER after_insert_${tableName}
+    //   // AFTER INSERT ON ${tableName}
+    //   // BEGIN
+    //   //     DELETE FROM temp_last_inserted_id;
+    //   //     INSERT INTO temp_last_inserted_id (id) VALUES (new.id);
+    //   // END;`,
+    //   //             ),
+    //   //           )
+    //   //
+    //   //           logger(
+    //   //             '[db/actors] [migrate] createTriggerQuery',
+    //   //             createTriggerQuery,
+    //   //           )
+    //   //         }
+    // }
+    // static async exec(sql: string, params: any[]) {
+    //   const rowsToReturnRaw: SqliteWasmResult[] = []
+    //   const rowsValues: string[][] = []
+    //   // For a single exec command, the callback potentially gets called several times -- once for each row.
+    //   // So we need to collect all rows into a final array to return (execResult).
+    //   const rowsToReturn = await new Promise((resolve, reject) => {
+    //    this.sqliteWasmClient('exec', {
+    //       dbId:this.dbId,
+    //       sql,
+    //       bind: params,
+    //       callback: (result) => {
+    //         // Checks if this is the final callback of the query
+    //         if (!result || !result.row || !result.rowNumber) {
+    //           const returnResult = []
+    //           for (const currRow of rowsToReturnRaw) {
+    //             returnResult.push(currRow.row)
+    //           }
+    //           resolve(returnResult)
+    //         } else {
+    //           // If not the final response, add this row to the return array
+    //           rowsToReturnRaw.push(result)
+    //         }
+    //       },
+    //     }).catch(async (error) => {
+    //       reject(error)
+    //     })
+    //   })
+    //   return rowsToReturn || []
+    // }
+    /**
+     * Execute a reactive query that emits new results whenever the underlying data changes.
+     *
+     * Supports two usage patterns:
+     * 1. SQL tag function: liveQuery((sql) => sql`SELECT * FROM models`)
+     * 2. Drizzle query builder: liveQuery(db.select().from(models))
+     *
+     * @param query - SQL query function or Drizzle query builder
+     * @returns Observable that emits arrays of query results
+     *
+     * @example
+     * ```typescript
+     * // Using SQL tag function
+     * const models$ = Db.liveQuery<ModelRow>(
+     *   (sql) => sql`SELECT * FROM models WHERE schema_file_id = ${schemaId}`
+     * )
+     *
+     * // Using Drizzle query builder
+     * const models$ = Db.liveQuery<ModelRow>(
+     *   appDb.select().from(models).where(eq(models.schemaFileId, schemaId))
+     * )
+     *
+     * models$.subscribe(models => {
+     *   console.log('Models updated:', models)
+     * })
+     * ```
+     */
+    static liveQuery(query) {
+        if (!this.sqlocalInstance) {
+            throw new Error('Database not initialized. Call prepareDb first.');
+        }
+        if (!this.sqlocalInstance.reactiveQuery) {
+            throw new Error('Reactive queries not enabled. Initialize SQLocalDrizzle with reactive: true.');
+        }
+        const baseObservable = new Observable((subscriber) => {
+            // Call SQLocal's reactiveQuery
+            const reactiveQueryResult = this.sqlocalInstance.reactiveQuery(query);
+            // Subscribe to SQLocal's subscription API
+            const subscription = reactiveQueryResult.subscribe((data) => {
+                // Log the actual data structure for debugging
+                if (data && data.length > 0) {
+                    // Try to extract IDs/names for logging (check common field names)
+                    data.map((d) => {
+                        return d.id || d.modelId || d.schemaId || d.modelFileId || d.schemaFileId || d.name || d.modelName || JSON.stringify(d).substring(0, 50);
+                    });
+                }
+                // Emit data through RxJS Observable (cast to T[] since SQLocal returns Record<string, any>[])
+                subscriber.next(data);
+            }, (err) => {
+                console.error('[BaseDb.liveQuery] SQLocal reactiveQuery error:', err);
+                // Emit error through RxJS Observable
+                subscriber.error(err);
+            });
+            // Cleanup: unsubscribe when Observable is unsubscribed
+            return () => {
+                subscription.unsubscribe();
+            };
+        });
+        // Use distinctUntilChanged with JSON.stringify comparison
+        // The comparator returns true if values are the same (skip emission)
+        return baseObservable.pipe(distinctUntilChanged((prev, curr) => {
+            // On first emission, prev will be undefined, so we always emit
+            if (prev === undefined) {
+                return false; // false = different, so emit
+            }
+            // Compare using JSON.stringify
+            try {
+                const prevJson = JSON.stringify(prev);
+                const currJson = JSON.stringify(curr);
+                // Return true if same (skip), false if different (emit)
+                return prevJson === currJson;
+            }
+            catch (error) {
+                // If JSON.stringify fails, fall back to reference equality
+                console.warn('[BaseDb.liveQuery] distinctUntilChanged: JSON.stringify failed, using reference equality', error);
+                return prev === curr;
+            }
+        }));
+    }
+}
+
+export { Db };
+//# sourceMappingURL=Db-DX08SxS9.js.map