@dialecte/core 0.8.0 → 0.9.0

package/dist/document/document.d.ts

@@ -107,7 +107,7 @@ export declare class Document<GenericConfig extends AnyDialecteConfig, GenericEx
         label?: string;
     }): Promise<T>;
     /**
-     * A commit refused with its engine lost may have landed (its outcome `running` or `unknown`): the document's
+     * A commit refused with its connection lost may have landed (its outcome `running` or `unknown`): the document's
      * history is read again and the change the store told of it posted. One known not to have landed changed nothing.
      */
     private readAgainAfterLoss;

package/dist/document/types.extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.extensions.d.ts","sourceRoot":"","sources":["../../src/document/types.extensions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.extensions.d.ts","sourceRoot":"","sources":["../../src/document/types.extensions.ts"],"names":[],"mappings":"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"}

package/dist/{engine-store-CIEqgPUb.js → engine-store-Deo9XNhr.js}

@@ -1,8 +1,8 @@
-import { i as e, r as t, t as n } from "./running-operations-vnijBvn7.js";
-import { M as r, P as i, a, b as o, v as s } from "./project-key-Ch34EtFa.js";
-import { G as c } from "./utils-USNkj4sT.js";
-// src/store/engine/wire/wire.constants.ts
-var l = {
+import { i as e, r as t, t as n } from "./running-operations-DCKvzlU7.js";
+import { G as r, N as i, h as a, j as o, r as s } from "./project-key-2ccZ-0gu.js";
+import { G as c } from "./utils-Cv4oHia0.js";
+// src/store/sqlite/served/engine-store.constants.ts
+var l = e(), u = {
 	registerDocument: { json: [{ argument: 0 }] },
 	getDocument: { read: !0 },
 	getDocuments: { read: !0 },
@@ -58,9 +58,9 @@ var l = {
 	attachBlob: { json: [{ argument: 1 }] },
 	detachBlob: {},
 	removeBlob: {}
-}, u = e(), d = class {
+}, d = class {
 	constructor(e) {
-		this.closed = !1, this.closings = 0, this.linkReleased = Promise.resolve(), this.operations = n(), this.listeners = /* @__PURE__ */ new Set(), this.stopNotices = m, this.lostWrites = /* @__PURE__ */ new Set(), i({ project: e.name }), this.name = e.name, this.connector = e.connector;
+		this.closed = !1, this.closings = 0, this.linkReleased = Promise.resolve(), this.operations = n(), this.listeners = /* @__PURE__ */ new Set(), this.stopNotices = m, this.lostWrites = /* @__PURE__ */ new Set(), a({ project: e.name }), this.name = e.name, this.connector = e.connector;
 	}
 	async open() {
 		let e = this.closings;
@@ -72,7 +72,7 @@ var l = {
 	async close() {
 		if (this.closed = !0, this.closings += 1, this.operations.count === 0) return this.releaseLink();
 		let e = this.operations.whenIdle();
-		u.markClosing({
+		l.markClosing({
 			name: this.name,
 			until: e
 		}), await e, await this.linkReleased;
@@ -88,7 +88,7 @@ var l = {
 		}
 	}
 	async destroyOnceIdle() {
-		await this.operations.whenIdle(), await u.settled({ name: this.name });
+		await this.operations.whenIdle(), await l.settled({ name: this.name });
 		let e = this.link && {
 			link: this.link,
 			letGo: this.releaseLink.bind(this)
@@ -173,23 +173,23 @@ var l = {
 		});
 	}
 	async exportFile(e) {
-		let { documentId: t, options: n, onProgress: r, signal: i } = e, o = crypto.randomUUID();
+		let { documentId: t, options: n, onProgress: r, signal: i } = e, a = crypto.randomUUID();
 		return this.operation({
 			readRetried: !1,
 			run: async (e) => {
-				let s = e.exportFile({
+				let o = e.exportFile({
 					documentId: t,
 					options: n,
-					exportId: o
+					exportId: a
 				}, r), c = f({
 					signal: i,
 					abort: function() {
-						return e.abortExport({ exportId: o });
+						return e.abortExport({ exportId: a });
 					}
 				});
 				try {
-					let e = await s;
-					return a({
+					let e = await o;
+					return s({
 						signal: i,
 						documentId: t
 					}), e;
@@ -256,7 +256,7 @@ var l = {
 		await this.call("removeBlob", e);
 	}
 	async call(e, ...t) {
-		let n = l[e];
+		let n = u[e];
 		return this.operation({
 			readRetried: n.read === !0,
 			run: function(n) {
@@ -291,7 +291,7 @@ var l = {
 	}
 	noteLostWrite(e) {
 		let t = c(e.thrown), n = t?.meta?.writeId;
-		t?.key === "STORE_ENGINE_LOST" && typeof n == "string" && this.lostWrites.add(n);
+		t?.key === "STORE_CONNECTION_LOST" && typeof n == "string" && this.lostWrites.add(n);
 	}
 	async tracked(e) {
 		this.operations.start();
@@ -319,10 +319,10 @@ var l = {
 			signal: t.signal,
 			link: n
 		});
-		o({
+		i({
 			listeners: this.listeners,
 			value: r,
-			of: s({ name: this.name })
+			of: o({ name: this.name })
 		});
 	}
 	releaseLink() {
@@ -341,8 +341,8 @@ function f(e) {
 }
 function p(e) {
 	let t = c(e.thrown);
-	return t?.key === "STORE_ENGINE_LOST" && t.meta?.reason === "host-gone";
+	return t?.key === "STORE_CONNECTION_LOST" && t.meta?.reason === "host-gone";
 }
 function m() {}
 function h() {}
-export { l as n, d as t };
+export { u as n, d as t };

package/dist/engine.constants-Bi4gw6BR.js

@@ -0,0 +1,205 @@
+import { H as e, W as t, q as n } from "./utils-Cv4oHia0.js";
+// src/store/sqlite/sqlite-errors.constants.ts
+var r = e({
+	STORE_PROTOCOL_MISMATCH: {
+		code: "D1012",
+		message: "Another version of the library holds the shared store connection",
+		explanation: {
+			when: "Another version of the library already holds the origin's hub, or an engine worker speaks another wire than the page (another tab runs an older or newer build, or the worker file was built from another copy).",
+			fix: "Close the other tabs of the app, or reload them all on the same version; build the engine worker file from the copy of `@dialecte/core` the page uses.",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	STORE_REALM_ID_TAKEN: {
+		code: "D1013",
+		message: "A view with this id is already connected to the shared store",
+		explanation: {
+			when: "A view joined the origin's hub with an id another connected view already uses.",
+			fix: "Give each view its own id; reload the page that reused one.",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	STORE_REALM_UNKNOWN: {
+		code: "D1014",
+		message: "The shared store does not know this view",
+		explanation: {
+			when: "A view spoke to the origin's hub without having joined it, or after it left; or a child view was bound by a page the hub no longer knows.",
+			fix: "Join (open the project) before reading or writing; reload a view that was disconnected; a child is bound again by its page (`createHubPort`, then `adoptHubPort`).",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	STORE_HUB_SPAWNERS_FIXED: {
+		code: "D1019",
+		message: "The page's hub connection runs another version of this dialecte's engine",
+		explanation: {
+			when: "`registerSqliteEngine({ url, dialectes })` named two versions of one dialecte (nothing kept), or the engines the app registered name a dialecte the page's connection already runs at another version, as `connectHub()` or a project opening on `sqlite` offers them to the hub: a page runs one version of each dialecte's engine (two would split a project's views between two engines). `meta.spawners` names the dialectes (id and version) refused; nothing of the call was added, nothing opened.",
+			fix: "Ship one version of each dialecte in the app, and name it once in `registerSqliteEngine({ url, dialectes })` and in `serveSqliteEngine({ dialectes })`, from the copy the app opens its projects with.",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	STORE_SQLITE_ENGINE_FIXED: {
+		code: "D1020",
+		message: "This page's SQLite engine is registered already",
+		explanation: {
+			when: "A second `registerSqliteEngine({ url, dialectes })` named another URL or other dialectes than the first (the same URL and the same dialectes, in any order, do nothing: a module evaluated twice). There is no additive call. `meta`: `registered` (kept), `asked` (refused), each `{ url, dialectes }`.",
+			fix: "Name all the dialectes of the app in one call, once, before the first project opens; the worker file serves them all (`serveSqliteEngine({ dialectes })`).",
+			docs: `${n}/api/dialecte#the-engine-worker-and-its-packaging`
+		}
+	},
+	PROJECT_LAYOUT_OUTDATED: {
+		code: "D7005",
+		message: "Project stored by another version of the library",
+		explanation: {
+			when: "The project's SQLite file was stored by another version of the library (another layout); nothing was written to it.",
+			fix: "Delete the project (the dialecte factory's `destroyProject({ name, storage: { type: 'sqlite' } })`) and import its files again with this version.",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	PROJECT_ENGINE_UNAVAILABLE: {
+		code: "D7006",
+		message: "No view can start the project engine",
+		explanation: {
+			when: "The project's SQLite engine could not be started or reached: its worker failed to load, could not load the engine's chunk (a build or a precache list that leaves it out), or never answered its open within the open budget; through the origin's hub, no open view offers an engine for the project's dialecte, or the engine never said it opened; a destroy still running past the open budget, or one asked by a page suspended before the hub granted it.",
+			fix: "Keep one tab of the app open and reload; check the `url` given to `registerSqliteEngine` points at the app's engine worker file and that it loads (the console names a script that fails); a destroy refused so is asked again once the project is closed elsewhere.",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	PROJECT_ENGINE_BUSY: {
+		code: "D7007",
+		message: "The project is still held by another engine",
+		explanation: {
+			when: "Another SQLite engine still holds the project's files (another tab or a worker that did not stop).",
+			fix: "Close the other tabs of the app, then open the project again.",
+			docs: `${n}/api/project#sqlite-errors`
+		}
+	},
+	PROJECT_DATABASE_LOST: {
+		code: "D7012",
+		message: "The project's database is gone",
+		explanation: {
+			when: "The project's files hold data but none of them is its SQLite database any more: the database file's header was damaged (by the disk, another program, or site data changed outside the app). Nothing is opened or changed: no empty database is made in its place. `meta.project` names the project.",
+			fix: "The project's data cannot be read back. Offer the user a reset, never automatically: `destroy()` on the same Project instance whose `open` was refused (keep it: `const project = new Project(params)`, then `await project.open(name)`) removes what the refused store holds, without opening it; `open(name)` then makes it again, empty, and its documents can be imported again.",
+			docs: `${n}/api/project#lifecycle`
+		}
+	},
+	PROJECT_ENGINE_NOT_DECLARED: {
+		code: "D7015",
+		message: "This project has no engine to open it on SQLite",
+		explanation: {
+			when: "A project was opened on `storage: { type: 'sqlite' }` but made by no dialecte's project factory: its dialecte's id or version is known to no one, so no engine can be asked for it. Nothing was opened.",
+			fix: "Make the project with the dialecte's project factory (`createProjectFactory({ dialecte })`, as a dialecte package exports it), or open it on another storage.",
+			docs: `${n}/api/project#sqlite-storage`
+		}
+	},
+	PROJECT_SQLITE_ENGINE_NOT_REGISTERED: {
+		code: "D7017",
+		message: "SQLite storage needs the engine registered for this dialecte",
+		explanation: {
+			when: "A project was opened (or destroyed by name) on `storage: { type: 'sqlite' }` in a realm that can store, but the app told the page of no engine for its dialecte: no `registerSqliteEngine` call, or one that does not name it. Nothing was started. A child its page bound through `adoptHubPort` is not refused: it goes through its page's engine. `meta`: `project`, `dialecteId`.",
+			fix: "Write the app's one worker file (`serveSqliteEngine({ dialectes })`) and call `registerSqliteEngine({ url, dialectes })` from `@dialecte/core/sqlite` once, before the first project opens, naming every dialecte of the app; `url` is a `?worker&url` import of that file. The registration is the page's: a frame of the same origin joining the hub on its own registers too (or is bound by its page); a frame of another origin never registers - it joins through `adoptHubPort` before it opens a project. Registered already? The registration is shared by every copy of @dialecte/core of the same SQLite version in the realm: one made by a copy of another version (a dialecte bringing its own core) is not seen - align the core versions.",
+			docs: `${n}/api/dialecte#the-engine-worker-and-its-packaging`
+		}
+	}
+});
+// src/store/sqlite/served/creation-refusal.ts
+function i(e) {
+	let { project: n, expectedCreationId: r, creationId: i } = e;
+	r !== void 0 && i !== r && t("PROJECT_DESTROYED_WHILE_AWAY", {
+		detail: `Project "${n}" was destroyed while this view was away${i === void 0 ? "" : ", and made again since"}: nothing of it was opened`,
+		meta: { project: n }
+	});
+}
+// src/store/sqlite/served/engine.constants.ts
+var a = "dialecte:engine:", o = {
+	heartbeat: "heartbeat",
+	busy: "busy",
+	progress: "progress",
+	event: "event"
+}, s = new URL(new URL("sqlite3.wasm", import.meta.url).href, "" + import.meta.url).href;
+function c() {
+	return typeof globalThis.process?.versions?.node == "string" ? void 0 : s;
+}
+// src/store/sqlite/engine/engine.constants.ts
+var l = {
+	cacheRule: {
+		mibPerGiB: 64,
+		floorMiB: 64,
+		ceilingMiB: 512
+	},
+	importWindowMs: 1e3,
+	reclaimSliceMs: 50,
+	reclaimPagesPerStatement: 256
+}, u = {
+	dialecteId: "dialecteId",
+	layoutVersion: "layoutVersion",
+	creationId: "creationId"
+}, d = {
+	offsetBasis: 2166136261,
+	prime: 16777619
+}, f = {
+	id: "TEXT NOT NULL UNIQUE",
+	name: "TEXT NOT NULL",
+	extension: "TEXT NOT NULL",
+	configKey: "TEXT NOT NULL",
+	createdAt: "INTEGER NOT NULL",
+	metadata: "TEXT",
+	status: "TEXT NOT NULL",
+	writeId: "TEXT",
+	path: "TEXT UNIQUE"
+}, p = {
+	id: "INTEGER PRIMARY KEY AUTOINCREMENT",
+	documentId: "TEXT NOT NULL",
+	sequenceNumber: "INTEGER",
+	timestamp: "INTEGER NOT NULL",
+	writeId: "TEXT NOT NULL",
+	state: "INTEGER NOT NULL"
+}, m = {
+	applied: 1,
+	undone: 0,
+	discarded: -1
+}, h = {
+	id: "TEXT PRIMARY KEY",
+	documentId: "TEXT NOT NULL",
+	entry: "TEXT NOT NULL"
+}, g = {
+	id: "TEXT PRIMARY KEY",
+	type: "TEXT NOT NULL",
+	bytes: "BLOB NOT NULL"
+}, _ = {
+	id: "TEXT NOT NULL",
+	tagName: "TEXT NOT NULL",
+	nsPrefix: "TEXT",
+	nsUri: "TEXT",
+	value: "TEXT",
+	parentId: "TEXT",
+	parentTagName: "TEXT",
+	attributes: "TEXT",
+	children: "TEXT"
+}, v = {
+	id: {
+		column: "id",
+		unique: !0
+	},
+	tag: {
+		column: "tagName",
+		unique: !1
+	}
+}, y = {
+	create: 0,
+	before: 1,
+	after: 2,
+	delete: 3
+}, b = "xch_", x = "_blobData", S = 1e3, C = ["attributes", "children"], w = Object.keys(_), T = w.join(", "), E = Object.keys(f).join(", "), D = Object.keys(_).map((e, t) => C.includes(e) ? `e.value->${t}` : `e.value->>${t}`), O = Object.keys(_).slice(1).map((e, t) => `${e} = u.c${t + 1}`).join(", "), k = D.map((e, t) => `${e} AS c${t}`).join(", "), A = 1048576, j = [
+	"registerDocument",
+	"updateDocument",
+	"removeDocument",
+	"bulkWrite",
+	"commit",
+	"undo",
+	"redo",
+	"addBlob",
+	"attachBlob",
+	"detachBlob",
+	"removeBlob"
+];
+export { s as C, i as D, o as E, r as O, b as S, a as T, O as _, l as a, D as b, j as c, A as d, u as f, v as g, w as h, p as i, m as l, T as m, h as n, f as o, _ as p, g as r, E as s, d as t, y as u, S as v, c as w, x, k as y };

package/dist/errors/{codes.d.ts → codes.constants.d.ts}

@@ -12,7 +12,7 @@ export declare const ERROR_CATALOG: {
         readonly code: "D0002";
         readonly message: "Assertion failed";
         readonly explanation: {
-            readonly when: "An `invariant` without its own key failed, or core met a state it never expects (a catalogue built wrong, an inconsistent export, an engine running an sqlite-wasm older than 3.54.1, which removes a project on a failed install).";
+            readonly when: "An `invariant` without its own key failed, or core met a state it never expects (a catalogue built wrong, an inconsistent export, a store running on a dependency older than the one it supports).";
             readonly fix: "Read `detail`: it names the condition. Give `invariant` a key of its own when the failure is one a caller should handle.";
             readonly docs: "https://dialecte.github.io/core/guide/development/state-and-errors#error-catalog";
         };
@@ -21,8 +21,8 @@ export declare const ERROR_CATALOG: {
         readonly code: "D1001";
         readonly message: "Failed to open database";
         readonly explanation: {
-            readonly when: "The project's database could not be opened (the SQLite file or its worker did not start), or the origin's hub could not be joined: its SharedWorker failed to start or was blocked, or a child's port went unanswered past the welcome budget (its page unbound it).";
-            readonly fix: "Check the browser supports the store (OPFS, workers, SharedWorker for the hub) and that no other tab holds the project; reload, or open the project with another storage. A child view refused so is bound again by its page (`createHubPort`, then `adoptHubPort`).";
+            readonly when: "The store could not open the project's data, or could not reach what serves it (its database, a worker, a server): it failed to start, was blocked, or went unanswered; the failure is the `cause` when there is one.";
+            readonly fix: "Check the browser supports what the store needs and that no other tab holds the project; reload, or open the project with another storage. The store's own docs name what it needs.";
             readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
         };
     };
@@ -111,38 +111,11 @@ export declare const ERROR_CATALOG: {
         readonly code: "D1011";
         readonly message: "Failed to read from database";
         readonly explanation: {
-            readonly when: "The SQLite store's database failed under a read; the failure is the `cause`.";
+            readonly when: "The store's database failed under a read; the failure is the `cause`.";
             readonly fix: "Read `cause`; reopen the project. A lasting failure means the file is damaged: import its documents again.";
             readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
         };
     };
-    readonly STORE_PROTOCOL_MISMATCH: {
-        readonly code: "D1012";
-        readonly message: "Another version of the library holds the shared store connection";
-        readonly explanation: {
-            readonly when: "Another version of the library already holds the shared store connection (another tab runs an older or newer build).";
-            readonly fix: "Close the other tabs of the app, or reload them all on the same version.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
-        };
-    };
-    readonly STORE_REALM_ID_TAKEN: {
-        readonly code: "D1013";
-        readonly message: "A view with this id is already connected to the shared store";
-        readonly explanation: {
-            readonly when: "A view joined the shared store with an id another connected view already uses.";
-            readonly fix: "Give each view its own id; reload the page that reused one.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
-        };
-    };
-    readonly STORE_REALM_UNKNOWN: {
-        readonly code: "D1014";
-        readonly message: "The shared store does not know this view";
-        readonly explanation: {
-            readonly when: "A view spoke to the shared store without having joined it, or after it left.";
-            readonly fix: "Join (open the project) before reading or writing; reload a view that was disconnected.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
-        };
-    };
     readonly STORE_VALUE_NOT_JSON: {
         readonly code: "D1015";
         readonly message: "A value handed to the store is not JSON";
@@ -156,8 +129,8 @@ export declare const ERROR_CATALOG: {
         readonly code: "D1016";
         readonly message: "This browser gives the page no storage for a project";
         readonly explanation: {
-            readonly when: "The browser gives the page no private file system (a private window), or a worker no synchronous file access, so the SQLite project store cannot create, open or destroy the project; nothing is changed.";
-            readonly fix: "Open the app in a normal (not private) window of a browser that supports the origin private file system.";
+            readonly when: "The browser gives the page none of the storage the store needs (a private window, an API the browser lacks), so it cannot create, open or destroy the project; nothing is changed.";
+            readonly fix: "Open the app in a normal (not private) window of a browser that supports what the project's store needs, or open the project with another storage.";
             readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
         };
     };
@@ -165,27 +138,27 @@ export declare const ERROR_CATALOG: {
         readonly code: "D1017";
         readonly message: "Not enough storage left for the project";
         readonly explanation: {
-            readonly when: "The origin has too little storage left: for a new project's files, for an import (eight times the file's size and at least 1 MiB, less the project's free pages), or the file system refused a write for want of space; nothing of the call applied. The SQLite project store answers it; the local (IndexedDB) store answers the failing write's own error (`STORE_COMMIT_FAILED`, `STORE_BULK_ADD_FAILED`, `STORE_BULK_UPDATE_FAILED`; an import `IMPORT_FAILED`) until it moves to SQLite; the in-memory store has no limit.";
+            readonly when: "The origin has too little storage left for what the call needs (a new project's files, an import's room ahead of it), or the store's storage refused a write for want of space; nothing of the call applied. A store that checks the room it needs answers it; the local (IndexedDB) store answers the failing write's own error (`STORE_COMMIT_FAILED`, `STORE_BULK_ADD_FAILED`, `STORE_BULK_UPDATE_FAILED`; an import `IMPORT_FAILED`); the in-memory store has no limit.";
             readonly fix: "Free storage for the origin (delete projects no longer needed) or import a smaller file, then try again; `meta.needed` and `meta.available` give the sizes when known.";
             readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
         };
     };
-    readonly STORE_ENGINE_LOST: {
+    readonly STORE_CONNECTION_LOST: {
         readonly code: "D1018";
-        readonly message: "The project engine stopped answering";
+        readonly message: "The store lost its connection";
         readonly explanation: {
-            readonly when: "A call to a project engine served from a worker lost that engine: it ended with what hosted it or gave no answer within its budget (`meta.reason` `'host-gone'`), it sent nothing for too long while the call waited (`'no-heartbeat'`, it may still finish), or the hub dropped this view with the page that bound it - frozen, gone, or unbinding it (`'realm-dropped'`: every call, `getWriteOutcome` too, is refused so until the view is bound again).";
-            readonly fix: "A Document's commit and a Project's import ask the outcome themselves, once: a commit that landed resolves; otherwise the refusal says `meta.outcome` - `not-applied` (make it again if wanted), `running` (a silent engine may still apply it: tell the user, read again later), `unknown` (it could not be asked), or `applied` for an import (its document is in the project; its diagnostics were lost). Elsewhere ask `getWriteOutcome({ writeId })` with `meta.writeId` before writing again; never retry a write blindly. For `'realm-dropped'`, every call is refused until the page binds the view again once it is back (`onRejoined`, then `createHubPort`, its port handed to the view's `adoptHubPort`).";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
+            readonly when: "A call to a store whose project is served elsewhere (a worker, another realm, a server) lost its connection to what serves it: that went away or gave no answer within its budget, sent nothing for too long while the call waited (the call may still finish), or dropped this view. `meta.reason` is the store's own word for why, listed in its docs; a write's refusal carries `meta.writeId`.";
+            readonly fix: "A Document's commit and a Project's import ask the outcome themselves, once: a commit that landed resolves; otherwise the refusal says `meta.outcome` - `not-applied` (make it again if wanted), `running` (what serves the store may still apply it: tell the user, read again later), `unknown` (it could not be asked), or `applied` for an import (its document is in the project; its diagnostics were lost). Elsewhere ask `getWriteOutcome({ writeId })` with `meta.writeId` before writing again; never retry a write blindly. The store's docs say what each `meta.reason` asks of the app.";
+            readonly docs: "https://dialecte.github.io/core/api/project#a-lost-connection";
         };
     };
-    readonly STORE_HUB_SPAWNERS_FIXED: {
-        readonly code: "D1019";
-        readonly message: "The page's hub connection runs another version of this dialecte's engine";
+    readonly STORE_KIND_TAKEN: {
+        readonly code: "D1021";
+        readonly message: "This storage type is registered already by another kind";
         readonly explanation: {
-            readonly when: "`connectHub({ spawners })` named a dialecte whose engine the page's connection already runs at another version, or a project was opened (or destroyed by name) on `sqlite` from a factory of such a version (the project offers its engine to the hub as it opens): a page runs one version of each dialecte's engine (two would split a project's views between two engines). A later call adds the engines of dialectes the page does not run yet. `meta.spawners` names the dialectes (id and version) refused; nothing of the call was added, nothing opened.";
-            readonly fix: "Ship one version of each dialecte in the app: register each dialecte's `factory.spawner` from the copy the app opens its projects with.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
+            readonly when: "`registerStorageKind({ type, kind })` named a type a kind of another `id` holds already: the first registration in the realm is kept, nothing replaced (the same `id` again does nothing: a module evaluated twice, or another copy of the package). `meta`: `type`, `registered` (the id kept), `asked` (the id refused).";
+            readonly fix: "Register each storage type once, from one package: import the entry that registers it from a single copy, or give the other kind a type of its own.";
+            readonly docs: "https://dialecte.github.io/core/guide/development/implementing-a-store#register-a-storage-kind";
         };
     };
     readonly ELEMENT_NOT_FOUND: {
@@ -476,47 +449,20 @@ export declare const ERROR_CATALOG: {
             readonly docs: "https://dialecte.github.io/core/api/project#blobs";
         };
     };
-    readonly PROJECT_LAYOUT_OUTDATED: {
-        readonly code: "D7005";
-        readonly message: "Project stored by another version of the library";
-        readonly explanation: {
-            readonly when: "The project file was stored by another version of the library (another layout); nothing was written to it.";
-            readonly fix: "Delete the project and import its files again with this version.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
-        };
-    };
-    readonly PROJECT_ENGINE_UNAVAILABLE: {
-        readonly code: "D7006";
-        readonly message: "No view can start the project engine";
-        readonly explanation: {
-            readonly when: "The project's engine could not be started or reached: its worker failed to load or never answered its open within the open budget; through the origin's hub, no open view offers an engine for the project's dialecte, or the engine never said it opened; a destroy still running past the open budget, or one asked by a page suspended before the hub granted it.";
-            readonly fix: "Keep one tab of the app open and reload; check the dialecte's `engineUrl` points at its worker and that it loads (the console names a script that fails); a destroy refused so is asked again once the project is closed elsewhere.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
-        };
-    };
-    readonly PROJECT_ENGINE_BUSY: {
-        readonly code: "D7007";
-        readonly message: "The project is still held by another engine";
-        readonly explanation: {
-            readonly when: "Another engine still holds the project (another tab or a worker that did not stop).";
-            readonly fix: "Close the other tabs of the app, then open the project again.";
-            readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
-        };
-    };
     readonly PROJECT_DIALECTE_MISMATCH: {
         readonly code: "D7008";
-        readonly message: "The project's engine or file is of another dialecte";
+        readonly message: "The project's data is of another dialecte";
         readonly explanation: {
-            readonly when: "A project file stored by another dialecte was opened (nothing of it written); or an engine was asked for a project of another dialecte than its own - the dialecte's `engineUrl` (its project factory's, or a hub spawner's) pointing at another dialecte's worker. Two dialectes' projects of one name are two projects: opening one never meets the other. `meta`: `project`, `projectDialecteId` (the engine's or the file's), `realmDialecteId` (the one asked).";
-            readonly fix: "Open the project with the dialecte it was created with; point the dialecte's `engineUrl` at its own worker.";
+            readonly when: "A project stored by another dialecte was opened (nothing of it written), or what serves the store (a worker, a server) was asked for a project of a dialecte it does not serve. Two dialectes' projects of one name are two projects: opening one never meets the other. `meta`: `project`, `realmDialecteId` (the one asked), and `projectDialecteId` (the project's), or the dialectes served, as the store's docs name them.";
+            readonly fix: "Open the project with the dialecte it was created with; serve every dialecte the app opens projects of, as the store's docs say.";
             readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
         };
     };
     readonly PROJECT_DIALECTE_VERSION_MISMATCH: {
         readonly code: "D7009";
-        readonly message: "The project engine runs another version of the dialecte";
+        readonly message: "The project's store runs another version of the dialecte";
         readonly explanation: {
-            readonly when: "The project's engine runs another version of the dialecte than this view.";
+            readonly when: "What serves the project's store (a worker, a server) runs another version of the dialecte than this view: another tab's, or one this page runs already for the project (a page runs one version of each dialecte).";
             readonly fix: "Reload every tab of the app so they run the same version.";
             readonly docs: "https://dialecte.github.io/core/api/project#store-errors";
         };
@@ -525,7 +471,7 @@ export declare const ERROR_CATALOG: {
         readonly code: "D7010";
         readonly message: "The project could not be deleted";
         readonly explanation: {
-            readonly when: "Destroying a project left its files in place: another tab or worker still holds one.";
+            readonly when: "Destroying a project left its data in place: another tab, window or connection still holds it.";
             readonly fix: "Close the other tabs or windows of the app that have the project open, then destroy it again.";
             readonly docs: "https://dialecte.github.io/core/api/project#lifecycle";
         };
@@ -539,20 +485,11 @@ export declare const ERROR_CATALOG: {
             readonly docs: "https://dialecte.github.io/core/api/project#lifecycle";
         };
     };
-    readonly PROJECT_DATABASE_LOST: {
-        readonly code: "D7012";
-        readonly message: "The project's database is gone";
-        readonly explanation: {
-            readonly when: "The project's files hold data but none of them is its database any more: the database file's header was damaged (by the disk, another program, or site data changed outside the app). Nothing is opened or changed: no empty database is made in its place. `meta.project` names the project.";
-            readonly fix: "The project's data cannot be read back. Offer the user a reset, never automatically: `destroy()` on the same Project instance whose `open` was refused (keep it: `const project = new Project(params)`, then `await project.open(name)`) removes what the refused store holds, without opening it; `open(name)` then makes it again, empty, and its documents can be imported again.";
-            readonly docs: "https://dialecte.github.io/core/api/project#lifecycle";
-        };
-    };
     readonly PROJECT_DESTROYED_WHILE_AWAY: {
         readonly code: "D7013";
         readonly message: "The project was deleted while this view was away";
         readonly explanation: {
-            readonly when: "A view's connection to a project came back - the page back from a freeze or the back/forward cache, its engine started again - and the project it had open was destroyed meanwhile by another tab (and maybe made again under its name): nothing is opened in its place and nothing of it is read. `meta.project` names the project.";
+            readonly when: "A view's connection to a project came back - the page back from a freeze or the back/forward cache, what serves its store started again - and the project it had open was destroyed meanwhile by another tab (and maybe made again under its name): nothing is opened in its place and nothing of it is read. `meta.project` names the project.";
             readonly fix: "Tell the user the project was deleted elsewhere; close it in this view (`project.close()`), then open it again by its name for what is there now, or choose another.";
             readonly docs: "https://dialecte.github.io/core/api/project#lifecycle";
         };
@@ -561,27 +498,18 @@ export declare const ERROR_CATALOG: {
         readonly code: "D7014";
         readonly message: "The project's name cannot name its files";
         readonly explanation: {
-            readonly when: "A project's name or its dialecte's id is empty, `.` or `..`: every store refuses it before it is built (a SQLite project's files sit in a directory named after both, which no directory can be); nothing was opened or written. `meta.project` and `meta.dialecteId` say which.";
+            readonly when: "A project's name or its dialecte's id is empty, `.` or `..`: every store refuses it before it is built (a store may name its files after both, which no file can be); nothing was opened or written. `meta.project` and `meta.dialecteId` say which.";
             readonly fix: "Give the project a name of its own (and the dialecte an id) other than an empty one, `.` or `..`.";
             readonly docs: "https://dialecte.github.io/core/api/project#lifecycle";
         };
     };
-    readonly PROJECT_ENGINE_NOT_DECLARED: {
-        readonly code: "D7015";
-        readonly message: "This project has no engine to open it on SQLite";
-        readonly explanation: {
-            readonly when: "A project was opened on `storage: { type: 'sqlite' }` but made by no dialecte's project factory: its engine (the dialecte's id, its version and its engine worker's URL) is known to no one, so nothing can start it. Nothing was opened.";
-            readonly fix: "Make the project with the dialecte's project factory (`createProjectFactory({ dialecte, engineUrl })`, as a dialecte package exports it), or open it on another storage.";
-            readonly docs: "https://dialecte.github.io/core/api/project#sqlite-storage";
-        };
-    };
-    readonly PROJECT_SQLITE_NOT_IMPORTED: {
-        readonly code: "D7016";
-        readonly message: "SQLite storage needs `import '@dialecte/core/sqlite'`";
+    readonly PROJECT_STORAGE_NOT_REGISTERED: {
+        readonly code: "D7018";
+        readonly message: "The project's storage type is not registered";
         readonly explanation: {
-            readonly when: "A project was opened (or destroyed by name) on `storage: { type: 'sqlite' }`, or a test asked for the `sqlite` test store, but the app never imported `@dialecte/core/sqlite`: the SQLite storage kind lives behind that entry, so an app that never imports it neither emits nor downloads the SQLite engine, its wasm or the hub. Nothing was opened.";
-            readonly fix: "Add `import '@dialecte/core/sqlite'` once to the app's entry (for tests, to the test runner's setup file), before the first project is opened on SQLite; or open the project on another storage. Imported already? The import registers the kind for every copy of @dialecte/core of the same SQLite storage version in the realm: a copy of another one (a dialecte bringing its own core) does not see it - align the core versions.";
-            readonly docs: "https://dialecte.github.io/core/api/project#sqlite-storage";
+            readonly when: "A project was opened (or destroyed by name), or a test asked for a test store, on a `storage.type` no kind is registered for in this realm: core serves `local`, `inMemory` and `custom` itself, every other type comes from the entry that registers it (`registerStorageKind`). Nothing was opened. `meta`: `project`, `type`.";
+            readonly fix: "Import the entry that registers the type once in the app's entry (for tests, in the test runner's setup file), before the first project opens on it; or open the project on another storage. Imported already? A kind is shared by every copy of @dialecte/core of the same storage version in the realm: one registered by a copy of another version (a package bringing its own core) is not seen - align the core versions.";
+            readonly docs: "https://dialecte.github.io/core/guide/development/implementing-a-store#register-a-storage-kind";
         };
     };
     readonly DOCUMENT_PATH_INVALID: {
@@ -603,4 +531,4 @@ export declare const ERROR_CATALOG: {
         };
     };
 };
-//# sourceMappingURL=codes.d.ts.map
+//# sourceMappingURL=codes.constants.d.ts.map

package/dist/errors/{codes.d.ts.map → codes.constants.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../src/errors/codes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8mBhB,CAAA"}
+{"version":3,"file":"codes.constants.d.ts","sourceRoot":"","sources":["../../src/errors/codes.constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsiBhB,CAAA"}

package/dist/errors/core-codes.constants.d.ts

@@ -0,0 +1,3 @@
+/** The codes of core's own catalogue: a dialecte's entry may not reuse one. */
+export declare const CORE_CODES: Set<string>;
+//# sourceMappingURL=core-codes.constants.d.ts.map

package/dist/errors/core-codes.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-codes.constants.d.ts","sourceRoot":"","sources":["../../src/errors/core-codes.constants.ts"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,eAAO,MAAM,UAAU,aAA2E,CAAA"}

package/dist/errors/errors.constants.d.ts

@@ -1,3 +1,8 @@
 /** Where core's published docs live: an explanation's `docs` page is under it. */
 export declare const CORE_DOCS_URL = "https://dialecte.github.io/core";
+/**
+ * The functions that only raise or report an error: the method is the first frame that is none of
+ * them. Matched on the function name only — a frame's file path may well contain one of these words.
+ */
+export declare const RAISING_FUNCTIONS: Set<string>;
 //# sourceMappingURL=errors.constants.d.ts.map