@haverstack/record-adapter-do-sqlite 0.28.0 → 0.30.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 } from '@haverstack/core';
-import { StackRecordAdapter, JournalOptions, MutateOptions, AspectWriteOptions, AdapterQuery, Reach, ElementWriteOptions } from '@haverstack/core/adapter';
+import { StackRecordAdapter, StoreWriters, JournalOptions, RecordHistory, MutateOptions, AspectWriteOptions, AdapterQuery, Reach, ElementWriteOptions, StoreSeed } from '@haverstack/core/adapter';
+import { StackCapabilities, ConfigContent, StackRecord, TypeId, QueryResult, FileId, BaseId, VersionsQuery, RecordVersion, JournalQuery, RecordJournalEntry, StackType, AssociationEdit, DataAssociation, AuthorityAssociation } from '@haverstack/core';
 
 /**
  * Normalizes a SQLite binding's call convention (array-bind-then-step,
@@ -31,12 +31,6 @@ interface SqlExecutor {
     transaction<T>(fn: () => T): T;
 }
 
-/** timezone is optional passthrough app metadata — no default. */
-type StackConfig = {
-    entityId: string;
-    timezone: string | undefined;
-};
-
 /**
  * The engine-independent half of a SQLite-backed StackRecordAdapter: the
  * capability declaration and the delegation of all twenty-three
@@ -57,10 +51,15 @@ type StackConfig = {
 declare abstract class SharedSqlRecordAdapter implements StackRecordAdapter {
     readonly capabilities: StackCapabilities;
     readonly ownerEntityId: string;
-    readonly timezone: string | undefined;
+    /** Each engine holds its database for one process; see docs/spec/adapters.md § Concurrency & storage ownership. */
+    readonly writers: StoreWriters;
     private readonly record;
-    protected constructor(exec: SqlExecutor, config: StackConfig);
+    /** Moved by every write method; see head(). */
+    private readonly written;
+    protected constructor(exec: SqlExecutor, config: ConfigContent);
+    head(): Promise<string>;
     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>;
@@ -76,7 +75,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>;
@@ -149,17 +147,23 @@ type DoSQLiteRecordAdapterOpenOptions = {
      * provider is called only when the DO's storage has none yet.
      */
     ownerEntityId: string | (() => string | Promise<string>);
-    /** IANA timezone string e.g. "America/New_York". Optional passthrough app metadata — no default. */
-    timezone?: string;
+    seed?: never;
+} | {
+    /**
+     * The `_config` record and history new storage is created holding: a
+     * copy's source's. Storage that already holds a store refuses it.
+     */
+    seed: StoreSeed;
+    ownerEntityId?: never;
 };
 declare class DoSQLiteRecordAdapter extends SharedSqlRecordAdapter {
     private constructor();
     /**
      * Open the adapter for a DO instance, creating its storage on first use.
      * A DO id either already has a config record (reattach) or it doesn't
-     * (first call — opts.ownerEntityId/timezone become the config), so there
-     * is no `create` option. Schema DDL is `CREATE TABLE IF NOT EXISTS`, so
-     * running it every call is idempotent and cheap.
+     * (first call — opts.ownerEntityId becomes the config), so there
+     * is no `create` option. A new store's tables are written in the same
+     * transaction as its config record, so storage holds a whole store or none.
      *
      * DO SQLite manages its own durability and rejects PRAGMA journal_mode
      * outright ("not authorized") — verified against the real runtime, not

package/dist/index.js

@@ -1,9 +1,17 @@
+import { trackWrites, 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';
 
 // ../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,
@@ -23,7 +31,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,
@@ -49,7 +57,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')),
@@ -63,7 +71,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,
@@ -81,7 +89,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,
@@ -105,7 +113,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,
@@ -123,7 +131,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)),
@@ -139,39 +147,39 @@ 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 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',
@@ -179,10 +187,11 @@ var FTS5_SCHEMA_SQL = `
   );
 `;
 var PRAGMA_FOREIGN_KEYS_ON = `PRAGMA foreign_keys = ON;`;
-var applyRecordSchema = (exec, opts) => {
+var PRAGMA_JOURNAL_MODE_WAL = `PRAGMA journal_mode = WAL;`;
+var applyConnectionPragmas = (exec, opts) => {
   exec.exec(PRAGMA_FOREIGN_KEYS_ON);
-  exec.exec(RECORD_SCHEMA_SQL);
-  exec.exec(FTS5_SCHEMA_SQL);
+  if (opts.wal)
+    exec.exec(PRAGMA_JOURNAL_MODE_WAL);
 };
 
 // ../sqlite-shared/dist/fts5.js
@@ -268,22 +277,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 toBase64 = (text) => {
   const bytes = new TextEncoder().encode(text);
   let binary = "";
@@ -953,6 +946,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;
@@ -1048,42 +1070,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);
@@ -1308,7 +1359,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;
     }
@@ -1324,14 +1375,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
@@ -1345,8 +1388,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);
     }
   }
@@ -1355,9 +1399,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)
@@ -1365,26 +1409,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])) {
@@ -1549,7 +1587,51 @@ 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/record-adapter.js
+// ../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 }));
+};
 var SQLITE_RECORD_CAPABILITIES = {
   filter: {
     content: "path",
@@ -1570,12 +1652,17 @@ var SQLITE_RECORD_CAPABILITIES = {
 var SharedSqlRecordAdapter = class {
   capabilities = SQLITE_RECORD_CAPABILITIES;
   ownerEntityId;
-  timezone;
+  /** Each engine holds its database for one process; see docs/spec/adapters.md § Concurrency & storage ownership. */
+  writers = "owner";
   record;
+  /** Moved by every write method; see head(). */
+  written = trackWrites(this);
   constructor(exec, config) {
     this.record = new SharedSqlRecordLogic({ exec });
-    this.ownerEntityId = config.entityId;
-    this.timezone = config.timezone;
+    this.ownerEntityId = config.ownerEntityId;
+  }
+  async head() {
+    return this.written.read();
   }
   // -------------------------------------------------------
   // Records
@@ -1583,6 +1670,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);
   }
@@ -1625,9 +1715,6 @@ var SharedSqlRecordAdapter = class {
   getVersion(id, version) {
     return this.record.getVersion(id, version);
   }
-  saveVersion(id, version) {
-    return this.record.saveVersion(id, version);
-  }
   // -------------------------------------------------------
   // Change journal
   // -------------------------------------------------------
@@ -1699,9 +1786,9 @@ var DoSQLiteRecordAdapter = class _DoSQLiteRecordAdapter extends SharedSqlRecord
   /**
    * Open the adapter for a DO instance, creating its storage on first use.
    * A DO id either already has a config record (reattach) or it doesn't
-   * (first call — opts.ownerEntityId/timezone become the config), so there
-   * is no `create` option. Schema DDL is `CREATE TABLE IF NOT EXISTS`, so
-   * running it every call is idempotent and cheap.
+   * (first call — opts.ownerEntityId becomes the config), so there
+   * is no `create` option. A new store's tables are written in the same
+   * transaction as its config record, so storage holds a whole store or none.
    *
    * DO SQLite manages its own durability and rejects PRAGMA journal_mode
    * outright ("not authorized") — verified against the real runtime, not
@@ -1709,20 +1796,12 @@ var DoSQLiteRecordAdapter = class _DoSQLiteRecordAdapter extends SharedSqlRecord
    */
   static async open(storage, opts) {
     const exec = new DurableObjectSqliteExecutor(storage);
-    applyRecordSchema(exec);
-    let config = tryReadStackConfig(exec);
-    if (config) {
-      if (typeof opts.ownerEntityId === "string" && opts.ownerEntityId !== config.entityId) {
-        throw new OwnerMismatchError(
-          opts.ownerEntityId,
-          config.entityId,
-          "the Durable Object storage"
-        );
-      }
-    } else {
-      const ownerEntityId = typeof opts.ownerEntityId === "function" ? await opts.ownerEntityId() : opts.ownerEntityId;
-      config = insertConfigRecord(exec, ownerEntityId, opts.timezone);
-    }
+    const config = await openStore(exec, {
+      ...opts,
+      mode: "ifMissing",
+      where: "the Durable Object storage",
+      wal: false
+    });
     return new _DoSQLiteRecordAdapter(exec, config);
   }
   // -------------------------------------------------------