@haverstack/record-adapter-sqlite 0.35.0 → 0.36.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { StackCapabilities, StackRecord, TypeId, QueryResult, FileId, BaseId, VersionsQuery, RecordVersion, JournalQuery, RecordJournalEntry, StackType, AssociationEdit, DataAssociation, AuthorityAssociation, Actor } from '@haverstack/core';
-import { StackRecordAdapter, JournalOptions, MutateOptions, AspectWriteOptions, AdapterQuery, Reach, ElementWriteOptions } from '@haverstack/core/adapter';
+import { StackCapabilities, ConfigContent, StackRecord, TypeId, QueryResult, FileId, BaseId, VersionsQuery, RecordVersion, JournalQuery, RecordJournalEntry, StackType, AssociationEdit, DataAssociation, AuthorityAssociation, Actor } from '@haverstack/core';
+import { StackRecordAdapter, JournalOptions, RecordHistory, MutateOptions, AspectWriteOptions, AdapterQuery, Reach, ElementWriteOptions, StoreSeed } from '@haverstack/core/adapter';
 import { StackTokenStore, TokenSession, TokenInfo } from '@haverstack/core/wire';
 
 /**
@@ -32,11 +32,10 @@ interface SqlExecutor {
     transaction<T>(fn: () => T): T;
 }
 
-/** timezone is optional passthrough app metadata — no default. */
-type StackConfig = {
-    entityId: string;
-    timezone: string | undefined;
-};
+/** What open() does when the store is missing or present, like O_CREAT / O_EXCL. */
+type StoreCreateMode = 'never' | 'ifMissing' | 'exclusive';
+/** A plain DID, or a lazy provider called only when a store is actually created. */
+type OwnerEntityIdInput = string | (() => string | Promise<string>);
 
 /**
  * The engine-independent half of a SQLite-backed StackRecordAdapter: the
@@ -58,10 +57,10 @@ type StackConfig = {
 declare abstract class SharedSqlRecordAdapter implements StackRecordAdapter {
     readonly capabilities: StackCapabilities;
     readonly ownerEntityId: string;
-    readonly timezone: string | undefined;
     private readonly record;
-    protected constructor(exec: SqlExecutor, config: StackConfig);
+    protected constructor(exec: SqlExecutor, config: ConfigContent);
     createRecord(record: StackRecord, opts?: JournalOptions): Promise<StackRecord>;
+    importRecord(record: StackRecord, history: RecordHistory): Promise<StackRecord>;
     getRecord(id: string): Promise<StackRecord | null>;
     patchContent(id: string, patch: Record<string, unknown | null>, opts?: MutateOptions): Promise<StackRecord>;
     setParent(id: string, parentId: string | null, opts?: AspectWriteOptions): Promise<StackRecord>;
@@ -77,7 +76,6 @@ declare abstract class SharedSqlRecordAdapter implements StackRecordAdapter {
     deleteUnreferencedAttachmentRecords(fileId: FileId, metadataBaseId: BaseId): Promise<StackRecord[]>;
     getVersions(id: string, query?: VersionsQuery): Promise<RecordVersion[]>;
     getVersion(id: string, version: number): Promise<RecordVersion | null>;
-    saveVersion(id: string, version: RecordVersion): Promise<void>;
     getJournal(id: string, query?: JournalQuery): Promise<RecordJournalEntry[]>;
     saveType(type: StackType): Promise<void>;
     getType(id: TypeId): Promise<StackType | null>;
@@ -159,15 +157,9 @@ declare class NativeTokenStore implements StackTokenStore {
  * spread-args run/get/all calls to it).
  */
 
-/** What open() does when the store is missing or present, like O_CREAT / O_EXCL. */
-type StoreCreateMode = 'never' | 'ifMissing' | 'exclusive';
-/** A plain DID, or a lazy provider called only when a store is actually created. */
-type OwnerEntityIdInput = string | (() => string | Promise<string>);
 type NativeSQLiteRecordAdapterOpenOptions = {
     /** Absolute path to the .db file. */
     path: string;
-    /** IANA timezone string e.g. "America/New_York". Consulted only when a store is created. No default. */
-    timezone?: string;
     /**
      * Open even if a lock file from another live process is present.
      * Only needed if that process is gone but its PID was reused by
@@ -180,6 +172,7 @@ type NativeSQLiteRecordAdapterOpenOptions = {
     create?: 'never';
     /** Checked against the existing store's owner; a mismatch throws OwnerMismatchError. */
     ownerEntityId?: string;
+    seed?: never;
 } | {
     /** `'ifMissing'` opens the store if present and creates it if not; `'exclusive'` creates it and fails if present. */
     create: 'ifMissing' | 'exclusive';
@@ -188,6 +181,13 @@ type NativeSQLiteRecordAdapterOpenOptions = {
      * existing store's owner; a lazy provider is never called just to compare.
      */
     ownerEntityId: OwnerEntityIdInput;
+    seed?: never;
+} | {
+    /** A seed only creates, as `'exclusive'` does: an existing store refuses it. */
+    create?: never;
+    /** The `_config` record and history the store is created holding: a copy's source's. */
+    seed: StoreSeed;
+    ownerEntityId?: never;
 });
 declare class NativeSQLiteRecordAdapter extends SharedSqlRecordAdapter {
     private readonly path;

package/dist/index.js

@@ -1,6 +1,6 @@
-import { existsSync, writeFileSync, unlinkSync, readFileSync } from 'fs';
+import { existsSync, rmSync, writeFileSync, unlinkSync, readFileSync } from 'fs';
+import { OwnerMismatchError, newStoreSeed, softDeletedRefusal, sameAssociationSet, ElementSetMovedError, FormatMismatchError, contentSortEntry, constantSortEntry, contentSortKey, parseContentFilterKey } from '@haverstack/core/adapter';
 import { StackConflictError, applyMergePatch, StackNotFoundError, StackVersionConflictError, StackBadRequestError, NATIVE_SORT_FIELDS } from '@haverstack/core';
-import { OwnerMismatchError, softDeletedRefusal, sameAssociationSet, ElementSetMovedError, contentSortEntry, constantSortEntry, contentSortKey, parseContentFilterKey } from '@haverstack/core/adapter';
 import { randomBytes, createHash } from 'crypto';
 
 // src/node-sqlite.ts
@@ -9,8 +9,16 @@ var { DatabaseSync } = process.getBuiltinModule(
 );
 
 // ../sqlite-shared/dist/schema.js
+var FORMAT_VERSION = 1;
 var RECORD_SCHEMA_SQL = `
-  CREATE TABLE IF NOT EXISTS records (
+  -- Which layout this store is, in its one row, so an export names the one
+  -- a reader holds. See docs/spec/portability.md \xA7 The portable format.
+  CREATE TABLE format (
+    id      INTEGER PRIMARY KEY CHECK (id = 1),
+    version INTEGER NOT NULL
+  ) STRICT;
+
+  CREATE TABLE records (
     id          TEXT PRIMARY KEY,
     type_id     TEXT NOT NULL,
     created_at  INTEGER NOT NULL,
@@ -30,7 +38,7 @@ var RECORD_SCHEMA_SQL = `
   -- A record's data associations: tags, attachments and relationships.
   -- Its permissions are in their own table below, so no predicate over this
   -- one can match a grantee as a relationship target.
-  CREATE TABLE IF NOT EXISTS associations (
+  CREATE TABLE associations (
     record_id     TEXT NOT NULL REFERENCES records(id),
     kind          TEXT NOT NULL CHECK (kind IN ('tag', 'attachment', 'relationship')),
     label         TEXT NOT NULL,
@@ -56,7 +64,7 @@ var RECORD_SCHEMA_SQL = `
   -- grantee; a group grantee's role is in the key, because member and
   -- admin name two different sets of people.
   -- See docs/spec/access-control.md \xA7 Record-level permissions.
-  CREATE TABLE IF NOT EXISTS permissions (
+  CREATE TABLE permissions (
     record_id    TEXT NOT NULL REFERENCES records(id),
     kind         TEXT NOT NULL CHECK (kind IN ('permission', 'anyone')),
     label        TEXT NOT NULL CHECK (label IN ('read', 'write')),
@@ -70,7 +78,7 @@ var RECORD_SCHEMA_SQL = `
   -- associations column: none of those aspects bumps version, so no
   -- version ever snapshots one. See
   -- docs/spec/versioning.md \xA7 Version history.
-  CREATE TABLE IF NOT EXISTS versions (
+  CREATE TABLE versions (
     record_id   TEXT NOT NULL REFERENCES records(id),
     version     INTEGER NOT NULL,
     type_id     TEXT NOT NULL,
@@ -88,7 +96,7 @@ var RECORD_SCHEMA_SQL = `
   -- by design \u2014 content lives on a versions row, and copying it here
   -- would make the journal the larger of the two stores.
   -- See docs/spec/journal.md.
-  CREATE TABLE IF NOT EXISTS journal (
+  CREATE TABLE journal (
     record_id   TEXT NOT NULL REFERENCES records(id),
     seq         INTEGER NOT NULL,
     at          INTEGER NOT NULL,
@@ -112,7 +120,7 @@ var RECORD_SCHEMA_SQL = `
     PRIMARY KEY (record_id, seq)
   ) STRICT;
 
-  CREATE TABLE IF NOT EXISTS types (
+  CREATE TABLE types (
     id            TEXT PRIMARY KEY,
     base_id       TEXT NOT NULL,
     version       INTEGER NOT NULL,
@@ -130,7 +138,7 @@ var RECORD_SCHEMA_SQL = `
   -- value_rank is 0 for a numeric value and 1 for a text one \u2014 the same
   -- split as "num_value IS NULL", but non-null, so one index can carry
   -- the whole ordering. file_id is set only for a 'file-ref' field.
-  CREATE TABLE IF NOT EXISTS content_index (
+  CREATE TABLE content_index (
     record_id  TEXT NOT NULL REFERENCES records(id),
     field      TEXT NOT NULL,
     value_rank INTEGER NOT NULL CHECK (value_rank IN (0, 1)),
@@ -146,35 +154,35 @@ var RECORD_SCHEMA_SQL = `
   -- leaves the planner sorting every match before it can honor LIMIT.
   -- deleted_at and unlisted_at get none: an index on a column every query
   -- tests IS NULL only lures the planner off the one answering ORDER BY.
-  CREATE INDEX IF NOT EXISTS idx_records_type_id      ON records(type_id, created_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_parent_id    ON records(parent_id, created_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_entity_id    ON records(entity_id, created_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_app_id       ON records(app_id, created_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_principal_id ON records(principal_id, created_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_created_at   ON records(created_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_updated_at   ON records(updated_at, id);
-  CREATE INDEX IF NOT EXISTS idx_records_version      ON records(version, id);
+  CREATE INDEX idx_records_type_id      ON records(type_id, created_at, id);
+  CREATE INDEX idx_records_parent_id    ON records(parent_id, created_at, id);
+  CREATE INDEX idx_records_entity_id    ON records(entity_id, created_at, id);
+  CREATE INDEX idx_records_app_id       ON records(app_id, created_at, id);
+  CREATE INDEX idx_records_principal_id ON records(principal_id, created_at, id);
+  CREATE INDEX idx_records_created_at   ON records(created_at, id);
+  CREATE INDEX idx_records_updated_at   ON records(updated_at, id);
+  CREATE INDEX idx_records_version      ON records(version, id);
 
   -- Each association index ends with record_id so the semi-joins in
   -- query.ts read the matching record ids out of the index alone.
   -- idx_assoc_related carries related_ns ahead of related_id because a
   -- record- or entity-scoped target always stores '' there, which
   -- buildQueryPlan states explicitly to keep the prefix contiguous.
-  CREATE INDEX IF NOT EXISTS idx_assoc_kind_label   ON associations(kind, label, record_id);
-  CREATE INDEX IF NOT EXISTS idx_assoc_kind_file_id ON associations(kind, file_id, record_id);
-  CREATE INDEX IF NOT EXISTS idx_assoc_related      ON associations(kind, related_scope, related_ns, related_id, record_id);
-  CREATE INDEX IF NOT EXISTS idx_types_base_id      ON types(base_id, version);
+  CREATE INDEX idx_assoc_kind_label   ON associations(kind, label, record_id);
+  CREATE INDEX idx_assoc_kind_file_id ON associations(kind, file_id, record_id);
+  CREATE INDEX idx_assoc_related      ON associations(kind, related_scope, related_ns, related_id, record_id);
+  CREATE INDEX idx_types_base_id      ON types(base_id, version);
 
   -- The permissions key with record_id moved last, so a scoped query reads
   -- the records carrying an element straight out of the index.
-  CREATE INDEX IF NOT EXISTS idx_permissions_element
+  CREATE INDEX idx_permissions_element
     ON permissions(kind, label, grantee_kind, grantee_id, role, record_id);
 
   -- The whole content ordering, in index order, for one field at a time:
   -- a content-sorted page is an ordered walk of a slice of this index.
-  CREATE INDEX IF NOT EXISTS idx_content_index_sort
+  CREATE INDEX idx_content_index_sort
     ON content_index(field, value_rank, num_value, text_key, text_value, record_id);
-  CREATE INDEX IF NOT EXISTS idx_content_index_file
+  CREATE INDEX idx_content_index_file
     ON content_index(file_id, record_id) WHERE file_id IS NOT NULL;
 `;
 var TOKENS_SCHEMA_SQL = `
@@ -189,7 +197,7 @@ var TOKENS_SCHEMA_SQL = `
   ) STRICT;
 `;
 var FTS5_SCHEMA_SQL = `
-  CREATE VIRTUAL TABLE IF NOT EXISTS records_fts USING fts5(
+  CREATE VIRTUAL TABLE records_fts USING fts5(
     content,
     content='records',
     content_rowid='rowid',
@@ -198,11 +206,10 @@ var FTS5_SCHEMA_SQL = `
 `;
 var PRAGMA_FOREIGN_KEYS_ON = `PRAGMA foreign_keys = ON;`;
 var PRAGMA_JOURNAL_MODE_WAL = `PRAGMA journal_mode = WAL;`;
-var applyRecordSchema = (exec, opts) => {
+var applyConnectionPragmas = (exec, opts) => {
   exec.exec(PRAGMA_FOREIGN_KEYS_ON);
-  exec.exec(PRAGMA_JOURNAL_MODE_WAL);
-  exec.exec(RECORD_SCHEMA_SQL);
-  exec.exec(FTS5_SCHEMA_SQL);
+  if (opts.wal)
+    exec.exec(PRAGMA_JOURNAL_MODE_WAL);
 };
 
 // ../sqlite-shared/dist/fts5.js
@@ -288,28 +295,6 @@ var restoreImplicitAnd = (query) => withPhrasesMasked(query, (masked) => masked.
 // ../sqlite-shared/dist/executor.js
 var isForeignKeyViolation = (err) => err instanceof Error && err.message.includes("FOREIGN KEY constraint failed");
 var isUniqueConstraintViolation = (err) => err instanceof Error && err.message.includes("UNIQUE constraint failed");
-
-// ../sqlite-shared/dist/config.js
-var CONFIG_ROW_SQL = `SELECT content FROM records WHERE id = '_config'`;
-var insertConfigRecord = (exec, entityId, timezone) => {
-  const now = Date.now();
-  exec.run(`INSERT INTO records (id, type_id, created_at, updated_at, content, version)
-     VALUES ('_config', '_config@1', ?, ?, ?, 1)`, [now, now, JSON.stringify({ entityId, timezone })]);
-  return { entityId, timezone };
-};
-var tryReadStackConfig = (exec) => {
-  const row = exec.get(CONFIG_ROW_SQL);
-  if (!row)
-    return null;
-  const content = JSON.parse(row.content);
-  return { entityId: content.entityId, timezone: content.timezone };
-};
-var readStackConfig = (exec) => {
-  const config = tryReadStackConfig(exec);
-  if (!config)
-    throw new Error("Stack database is missing its config record.");
-  return config;
-};
 var toBase64 = (text) => {
   const bytes = new TextEncoder().encode(text);
   let binary = "";
@@ -979,6 +964,35 @@ var versionRowValues = (version) => [
   version.updatedBy?.subjectId ?? null,
   version.updatedBy?.principalId ?? null
 ];
+var JOURNAL_COLUMNS = [
+  "record_id",
+  "seq",
+  "at",
+  "kind",
+  "ops",
+  "previous_parent_id",
+  "actor",
+  "associations",
+  "version",
+  "type_id",
+  "parent_id"
+];
+var INSERT_JOURNAL_SQL = `INSERT INTO journal (${JOURNAL_COLUMNS.join(", ")})
+   VALUES (${JOURNAL_COLUMNS.map(() => "?").join(", ")})`;
+var journalValues = (recordId, seq, at, entry, row) => [
+  recordId,
+  seq,
+  toMs(at),
+  entry.kind,
+  JSON.stringify(entry.ops),
+  // '' is the root; NULL is an entry that names no origin at all.
+  entry.previousParentId === void 0 ? null : entry.previousParentId ?? "",
+  entry.actor ? JSON.stringify(entry.actor) : null,
+  entry.associations?.length ? JSON.stringify(entry.associations) : null,
+  row.version,
+  row.typeId,
+  row.parentId
+];
 var SharedSqlRecordLogic = class {
   exec;
   searchIndex;
@@ -1074,42 +1088,71 @@ var SharedSqlRecordLogic = class {
    */
   async createRecord(record, opts = {}) {
     this.exec.transaction(() => {
-      try {
-        this.exec.run(`INSERT INTO records
+      this.insertRecord(record);
+      this.appendJournal(record.id, opts.journal);
+    });
+    return record;
+  }
+  /**
+   * createRecord() carrying the record's history as recorded: its version
+   * rows and journal entries, `seq` and `at` included, in the same
+   * transaction. Appends no entry of its own. See
+   * docs/spec/portability.md § Writing history.
+   */
+  async importRecord(record, history) {
+    this.exec.transaction(() => this.writeImported(record, history));
+    return record;
+  }
+  /**
+   * importRecord()'s write, for a caller already inside a transaction:
+   * writeNewStore() writes a store's `_config` seed through it, so the one
+   * Record a store starts with lands as every other Record does.
+   */
+  writeImported(record, history) {
+    this.insertRecord(record);
+    for (const version of history.versions)
+      this.insertVersionRow(record.id, version);
+    for (const entry of history.journal)
+      this.insertJournalRow(record.id, entry);
+  }
+  /**
+   * The record row and every table describing it, for a caller already
+   * inside a transaction. A duplicate id maps to StackConflictError.
+   */
+  insertRecord(record) {
+    try {
+      this.exec.run(`INSERT INTO records
           (id, type_id, created_at, updated_at, content, version,
            parent_id, entity_id, app_id, principal_id, updated_by, updated_via,
            deleted_at, unlisted_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-          record.id,
-          record.typeId,
-          toMs(record.createdAt),
-          toMs(record.updatedAt),
-          JSON.stringify(record.content),
-          record.version,
-          record.parentId ?? null,
-          record.createdBy?.subjectId ?? null,
-          record.appId ?? null,
-          record.createdBy?.principalId ?? null,
-          record.updatedBy?.subjectId ?? null,
-          record.updatedBy?.principalId ?? null,
-          record.deletedAt ? toMs(record.deletedAt) : null,
-          record.unlistedAt ? toMs(record.unlistedAt) : null
-        ]);
-      } catch (err) {
-        if (isUniqueConstraintViolation(err)) {
-          throw new StackConflictError(`Record already exists: "${record.id}"`);
-        }
-        throw err;
+        record.id,
+        record.typeId,
+        toMs(record.createdAt),
+        toMs(record.updatedAt),
+        JSON.stringify(record.content),
+        record.version,
+        record.parentId ?? null,
+        record.createdBy?.subjectId ?? null,
+        record.appId ?? null,
+        record.createdBy?.principalId ?? null,
+        record.updatedBy?.subjectId ?? null,
+        record.updatedBy?.principalId ?? null,
+        record.deletedAt ? toMs(record.deletedAt) : null,
+        record.unlistedAt ? toMs(record.unlistedAt) : null
+      ]);
+    } catch (err) {
+      if (isUniqueConstraintViolation(err)) {
+        throw new StackConflictError(`Record already exists: "${record.id}"`);
       }
-      if (record.associations?.length)
-        this.insertAssociations(record.id, record.associations);
-      if (record.permissions?.length)
-        this.insertPermissions(record.id, record.permissions);
-      this.searchIndex.insert(record.id, JSON.stringify(record.content));
-      this.contentIndex.sync(record.id, record.typeId, record.content);
-      this.appendJournal(record.id, opts.journal);
-    });
-    return record;
+      throw err;
+    }
+    if (record.associations?.length)
+      this.insertAssociations(record.id, record.associations);
+    if (record.permissions?.length)
+      this.insertPermissions(record.id, record.permissions);
+    this.searchIndex.insert(record.id, JSON.stringify(record.content));
+    this.contentIndex.sync(record.id, record.typeId, record.content);
   }
   async getRecord(id) {
     return this.readRecord(id);
@@ -1334,7 +1377,7 @@ var SharedSqlRecordLogic = class {
          VALUES (?, ?, ${VERSION_COLUMNS.map(() => "?").join(", ")})`, [id, version.version, ...versionRowValues(version)]);
     } catch (err) {
       if (isUniqueConstraintViolation(err)) {
-        throw new StackConflictError(`Version ${version.version} already exists for record "${id}" \u2014 a concurrent writer raced past this version. Use ifVersion to detect this before it happens.`);
+        throw new StackConflictError(`Version ${version.version} already exists for record "${id}"`);
       }
       throw err;
     }
@@ -1350,14 +1393,6 @@ var SharedSqlRecordLogic = class {
          SET ${VERSION_COLUMNS.map((c) => `${c} = ?`).join(", ")}
        WHERE record_id = ? AND version = ?`, [...versionRowValues(version), id, version.version]);
   }
-  /**
-   * Standalone snapshot write for tooling and tests — loud on any
-   * collision, since nothing here is about to bump the version. Mutating
-   * methods take a `snapshot` option instead; see snapshotBeforeMutation.
-   */
-  async saveVersion(id, version) {
-    this.insertVersionRow(id, version);
-  }
   /**
    * The snapshot half of a mutating method's atomic snapshot-then-mutate
    * transaction. A collision is a racing-writer conflict, except an orphan
@@ -1371,8 +1406,9 @@ var SharedSqlRecordLogic = class {
     } catch (err) {
       if (!(err instanceof StackConflictError))
         throw err;
-      if (this.currentVersion(id) !== version.version)
-        throw err;
+      if (this.currentVersion(id) !== version.version) {
+        throw new StackConflictError(`Version ${version.version} already exists for record "${id}" \u2014 a concurrent writer raced past this version. Use ifVersion to detect this before it happens.`);
+      }
       this.overwriteVersionRow(id, version);
     }
   }
@@ -1381,9 +1417,9 @@ var SharedSqlRecordLogic = class {
   // -------------------------------------------------------
   /**
    * Append one entry, stamped from the row as it now stands, so callers run
-   * this inside their write's transaction, after the write. `seq` is
-   * allocated in the INSERT itself, so no caller ever holds one it expects
-   * to be free. See docs/spec/journal.md § Ordering.
+   * this inside their write's transaction, after the write. `seq` is read
+   * from the log's maximum in that same transaction, so no caller ever holds
+   * one it expects to be free. See docs/spec/journal.md § Ordering.
    */
   appendJournal(recordId, entry) {
     if (!entry)
@@ -1391,26 +1427,20 @@ var SharedSqlRecordLogic = class {
     const row = this.exec.get("SELECT version, type_id, parent_id FROM records WHERE id = ?", [recordId]);
     if (!row)
       throw recordNotFound(recordId);
-    this.exec.run(`INSERT INTO journal
-        (record_id, seq, at, kind, ops, version, type_id, parent_id,
-         previous_parent_id, actor, associations)
-       VALUES (
-         ?,
-         (SELECT COALESCE(MAX(seq), 0) + 1 FROM journal WHERE record_id = ?),
-         ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-      recordId,
-      recordId,
-      toMs(/* @__PURE__ */ new Date()),
-      entry.kind,
-      JSON.stringify(entry.ops),
-      row.version,
-      row.type_id,
-      row.parent_id,
-      // '' is the root; NULL is an entry that names no origin at all.
-      entry.previousParentId === void 0 ? null : entry.previousParentId ?? "",
-      entry.actor ? JSON.stringify(entry.actor) : null,
-      entry.associations?.length ? JSON.stringify(entry.associations) : null
-    ]);
+    const { seq } = this.exec.get("SELECT COALESCE(MAX(seq), 0) + 1 AS seq FROM journal WHERE record_id = ?", [recordId]);
+    this.exec.run(INSERT_JOURNAL_SQL, journalValues(recordId, seq, /* @__PURE__ */ new Date(), entry, {
+      version: row.version,
+      typeId: row.type_id,
+      parentId: row.parent_id
+    }));
+  }
+  /** A whole entry as recorded, `seq` and `at` included — importRecord()'s half of the journal. */
+  insertJournalRow(recordId, entry) {
+    this.exec.run(INSERT_JOURNAL_SQL, journalValues(recordId, entry.seq, entry.at, entry, {
+      version: entry.version,
+      typeId: entry.typeId,
+      parentId: entry.parentId ?? null
+    }));
   }
   async getJournal(id, query = {}) {
     if (!this.exec.get("SELECT 1 FROM records WHERE id = ?", [id])) {
@@ -1575,6 +1605,52 @@ var ASSOCIATION_KEY = "record_id, kind, label, file_id, related_scope, related_i
 var PERMISSION_KEY = "record_id, kind, label, grantee_kind, grantee_id, role";
 var addsOf = (edits) => edits.flatMap((e) => e.op === "add" ? [e.association] : []);
 
+// ../sqlite-shared/dist/config.js
+var CONFIG_ROW_SQL = `SELECT content FROM records WHERE id = '_config'`;
+var missingStoreError = (where) => new Error(`Cannot open: no database found at ${where}. Pass create: 'ifMissing' or 'exclusive' to create one.`);
+var writeNewStore = (exec, seed) => {
+  exec.transaction(() => {
+    exec.exec(RECORD_SCHEMA_SQL);
+    exec.exec(FTS5_SCHEMA_SQL);
+    exec.run("INSERT INTO format (id, version) VALUES (1, ?)", [FORMAT_VERSION]);
+    new SharedSqlRecordLogic({ exec }).writeImported(seed.config, seed.history);
+  });
+  return seed.config.content;
+};
+var readStoredConfig = (exec, where) => {
+  const hasFormat = exec.get(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'format'`) !== void 0;
+  if (!hasFormat)
+    return null;
+  const version = exec.get("SELECT version FROM format WHERE id = 1")?.version;
+  if (version !== FORMAT_VERSION)
+    throw new FormatMismatchError(FORMAT_VERSION, version, where);
+  const { content } = exec.get(CONFIG_ROW_SQL);
+  return JSON.parse(content);
+};
+var openStore = async (exec, opts) => {
+  const stored = readStoredConfig(exec, opts.where);
+  if (!stored && opts.mode === "never")
+    throw missingStoreError(opts.where);
+  if (stored && (opts.mode === "exclusive" || opts.seed)) {
+    throw new Error(`Cannot create: database already exists at ${opts.where}. Pass create: 'never' or 'ifMissing' without a seed to open it.`);
+  }
+  applyConnectionPragmas(exec, { wal: opts.wal });
+  if (stored) {
+    const expected = typeof opts.ownerEntityId === "string" ? opts.ownerEntityId : void 0;
+    if (expected !== void 0 && expected !== stored.ownerEntityId) {
+      throw new OwnerMismatchError(expected, stored.ownerEntityId, opts.where);
+    }
+    return stored;
+  }
+  if (opts.seed)
+    return writeNewStore(exec, opts.seed);
+  const owner = typeof opts.ownerEntityId === "function" ? await opts.ownerEntityId() : opts.ownerEntityId;
+  if (!owner) {
+    throw new Error(`Cannot create: no ownerEntityId given for the new database at ${opts.where}.`);
+  }
+  return writeNewStore(exec, newStoreSeed({ ownerEntityId: owner }));
+};
+
 // ../sqlite-shared/dist/record-adapter.js
 var SQLITE_RECORD_CAPABILITIES = {
   filter: {
@@ -1596,12 +1672,10 @@ var SQLITE_RECORD_CAPABILITIES = {
 var SharedSqlRecordAdapter = class {
   capabilities = SQLITE_RECORD_CAPABILITIES;
   ownerEntityId;
-  timezone;
   record;
   constructor(exec, config) {
     this.record = new SharedSqlRecordLogic({ exec });
-    this.ownerEntityId = config.entityId;
-    this.timezone = config.timezone;
+    this.ownerEntityId = config.ownerEntityId;
   }
   // -------------------------------------------------------
   // Records
@@ -1609,6 +1683,9 @@ var SharedSqlRecordAdapter = class {
   createRecord(record, opts) {
     return this.record.createRecord(record, opts);
   }
+  importRecord(record, history) {
+    return this.record.importRecord(record, history);
+  }
   getRecord(id) {
     return this.record.getRecord(id);
   }
@@ -1651,9 +1728,6 @@ var SharedSqlRecordAdapter = class {
   getVersion(id, version) {
     return this.record.getVersion(id, version);
   }
-  saveVersion(id, version) {
-    return this.record.saveVersion(id, version);
-  }
   // -------------------------------------------------------
   // Change journal
   // -------------------------------------------------------
@@ -1857,51 +1931,22 @@ var NativeSQLiteRecordAdapter = class _NativeSQLiteRecordAdapter extends SharedS
    * See docs/spec/adapters.md § Construction.
    */
   static async open(opts) {
-    const mode = opts.create ?? "never";
-    const checkMode = (exists) => {
-      if (!exists && mode === "never") {
-        throw new Error(
-          `Cannot open: no database found at "${opts.path}". Pass create: 'ifMissing' or 'exclusive' to create one.`
-        );
-      }
-      if (exists && mode === "exclusive") {
-        throw new Error(
-          `Cannot create: database already exists at "${opts.path}". Pass create: 'never' or 'ifMissing' to open it.`
-        );
-      }
-    };
-    const existedBeforeLock = existsSync(opts.path);
-    checkMode(existedBeforeLock);
-    let newOwner;
-    if (!existedBeforeLock) {
-      newOwner = typeof opts.ownerEntityId === "function" ? await opts.ownerEntityId() : opts.ownerEntityId;
-      if (!newOwner) {
-        throw new Error(
-          `Cannot create: no ownerEntityId given for the new database at "${opts.path}".`
-        );
-      }
-    }
+    const mode = opts.seed ? "exclusive" : opts.create ?? "never";
+    const where = `"${opts.path}"`;
+    if (mode === "never" && !existsSync(opts.path)) throw missingStoreError(where);
     acquireLock(opts.path, opts.force);
+    const madeFile = !existsSync(opts.path);
     let db;
     try {
-      const exists = existsSync(opts.path);
-      checkMode(exists);
       db = new DatabaseSync(opts.path);
       const exec = new NativeSqliteExecutor(db);
-      applyRecordSchema(exec, { wal: true });
-      let config;
-      if (exists) {
-        config = readStackConfig(exec);
-        if (typeof opts.ownerEntityId === "string" && opts.ownerEntityId !== config.entityId) {
-          throw new OwnerMismatchError(opts.ownerEntityId, config.entityId, `"${opts.path}"`);
-        }
-      } else {
-        if (!newOwner) throw new Error(`Cannot create: "${opts.path}" vanished while opening.`);
-        config = insertConfigRecord(exec, newOwner, opts.timezone);
-      }
+      const config = await openStore(exec, { ...opts, mode, where, wal: true });
       return new _NativeSQLiteRecordAdapter(opts.path, db, exec, config);
     } catch (err) {
       db?.close();
+      if (madeFile) {
+        for (const suffix of ["", "-wal", "-shm"]) rmSync(`${opts.path}${suffix}`, { force: true });
+      }
       releaseLock(opts.path);
       throw err;
     }