@dialecte/core 0.8.1 → 0.10.0

package/dist/{utils-USNkj4sT.js → utils-Cv4oHia0.js}

@@ -1,5 +1,10 @@
 // src/errors/errors.constants.ts
-var e = "https://dialecte.github.io/core", t = {
+var e = "https://dialecte.github.io/core", t = /* @__PURE__ */ new Set([
+	"throwDialecteError",
+	"createDialecteError",
+	"invariant",
+	"reportFailure"
+]), n = {
 	UNKNOWN: {
 		code: "D0001",
 		message: "An unknown error occurred",
@@ -13,7 +18,7 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D0002",
 		message: "Assertion failed",
 		explanation: {
-			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).",
+			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).",
 			fix: "Read `detail`: it names the condition. Give `invariant` a key of its own when the failure is one a caller should handle.",
 			docs: `${e}/guide/development/state-and-errors#error-catalog`
 		}
@@ -22,8 +27,8 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D1001",
 		message: "Failed to open database",
 		explanation: {
-			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).",
-			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`).",
+			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.",
+			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.",
 			docs: `${e}/api/project#store-errors`
 		}
 	},
@@ -112,38 +117,11 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D1011",
 		message: "Failed to read from database",
 		explanation: {
-			when: "The SQLite store's database failed under a read; the failure is the `cause`.",
+			when: "The store's database failed under a read; the failure is the `cause`.",
 			fix: "Read `cause`; reopen the project. A lasting failure means the file is damaged: import its documents again.",
 			docs: `${e}/api/project#store-errors`
 		}
 	},
-	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 shared store connection (another tab runs an older or newer build).",
-			fix: "Close the other tabs of the app, or reload them all on the same version.",
-			docs: `${e}/api/project#store-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 shared store with an id another connected view already uses.",
-			fix: "Give each view its own id; reload the page that reused one.",
-			docs: `${e}/api/project#store-errors`
-		}
-	},
-	STORE_REALM_UNKNOWN: {
-		code: "D1014",
-		message: "The shared store does not know this view",
-		explanation: {
-			when: "A view spoke to the shared store without having joined it, or after it left.",
-			fix: "Join (open the project) before reading or writing; reload a view that was disconnected.",
-			docs: `${e}/api/project#store-errors`
-		}
-	},
 	STORE_VALUE_NOT_JSON: {
 		code: "D1015",
 		message: "A value handed to the store is not JSON",
@@ -157,8 +135,8 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D1016",
 		message: "This browser gives the page no storage for a project",
 		explanation: {
-			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.",
-			fix: "Open the app in a normal (not private) window of a browser that supports the origin private file system.",
+			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.",
+			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.",
 			docs: `${e}/api/project#store-errors`
 		}
 	},
@@ -166,27 +144,27 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D1017",
 		message: "Not enough storage left for the project",
 		explanation: {
-			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.",
+			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.",
 			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.",
 			docs: `${e}/api/project#store-errors`
 		}
 	},
-	STORE_ENGINE_LOST: {
+	STORE_CONNECTION_LOST: {
 		code: "D1018",
-		message: "The project engine stopped answering",
+		message: "The store lost its connection",
 		explanation: {
-			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).",
-			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`).",
-			docs: `${e}/api/project#store-errors`
+			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`.",
+			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.",
+			docs: `${e}/api/project#a-lost-connection`
 		}
 	},
-	STORE_HUB_SPAWNERS_FIXED: {
-		code: "D1019",
-		message: "The page's hub connection runs another version of this dialecte's engine",
+	STORE_KIND_TAKEN: {
+		code: "D1021",
+		message: "This storage type is registered already by another kind",
 		explanation: {
-			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.",
-			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.",
-			docs: `${e}/api/project#store-errors`
+			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).",
+			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.",
+			docs: `${e}/guide/development/implementing-a-store#register-a-storage-kind`
 		}
 	},
 	ELEMENT_NOT_FOUND: {
@@ -477,47 +455,20 @@ var e = "https://dialecte.github.io/core", t = {
 			docs: `${e}/api/project#blobs`
 		}
 	},
-	PROJECT_LAYOUT_OUTDATED: {
-		code: "D7005",
-		message: "Project stored by another version of the library",
-		explanation: {
-			when: "The project file was stored by another version of the library (another layout); nothing was written to it.",
-			fix: "Delete the project and import its files again with this version.",
-			docs: `${e}/api/project#store-errors`
-		}
-	},
-	PROJECT_ENGINE_UNAVAILABLE: {
-		code: "D7006",
-		message: "No view can start the project engine",
-		explanation: {
-			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.",
-			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.",
-			docs: `${e}/api/project#store-errors`
-		}
-	},
-	PROJECT_ENGINE_BUSY: {
-		code: "D7007",
-		message: "The project is still held by another engine",
-		explanation: {
-			when: "Another engine still holds the project (another tab or a worker that did not stop).",
-			fix: "Close the other tabs of the app, then open the project again.",
-			docs: `${e}/api/project#store-errors`
-		}
-	},
 	PROJECT_DIALECTE_MISMATCH: {
 		code: "D7008",
-		message: "The project's engine or file is of another dialecte",
+		message: "The project's data is of another dialecte",
 		explanation: {
-			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).",
-			fix: "Open the project with the dialecte it was created with; point the dialecte's `engineUrl` at its own worker.",
+			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.",
+			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.",
 			docs: `${e}/api/project#store-errors`
 		}
 	},
 	PROJECT_DIALECTE_VERSION_MISMATCH: {
 		code: "D7009",
-		message: "The project engine runs another version of the dialecte",
+		message: "The project's store runs another version of the dialecte",
 		explanation: {
-			when: "The project's engine runs another version of the dialecte than this view.",
+			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).",
 			fix: "Reload every tab of the app so they run the same version.",
 			docs: `${e}/api/project#store-errors`
 		}
@@ -526,7 +477,7 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D7010",
 		message: "The project could not be deleted",
 		explanation: {
-			when: "Destroying a project left its files in place: another tab or worker still holds one.",
+			when: "Destroying a project left its data in place: another tab, window or connection still holds it.",
 			fix: "Close the other tabs or windows of the app that have the project open, then destroy it again.",
 			docs: `${e}/api/project#lifecycle`
 		}
@@ -540,20 +491,11 @@ var e = "https://dialecte.github.io/core", t = {
 			docs: `${e}/api/project#lifecycle`
 		}
 	},
-	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 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: `${e}/api/project#lifecycle`
-		}
-	},
 	PROJECT_DESTROYED_WHILE_AWAY: {
 		code: "D7013",
 		message: "The project was deleted while this view was away",
 		explanation: {
-			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.",
+			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.",
 			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.",
 			docs: `${e}/api/project#lifecycle`
 		}
@@ -562,27 +504,18 @@ var e = "https://dialecte.github.io/core", t = {
 		code: "D7014",
 		message: "The project's name cannot name its files",
 		explanation: {
-			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.",
+			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.",
 			fix: "Give the project a name of its own (and the dialecte an id) other than an empty one, `.` or `..`.",
 			docs: `${e}/api/project#lifecycle`
 		}
 	},
-	PROJECT_ENGINE_NOT_DECLARED: {
-		code: "D7015",
-		message: "This project has no engine to open it on SQLite",
+	PROJECT_STORAGE_NOT_REGISTERED: {
+		code: "D7018",
+		message: "The project's storage type is not registered",
 		explanation: {
-			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.",
-			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.",
-			docs: `${e}/api/project#sqlite-storage`
-		}
-	},
-	PROJECT_SQLITE_NOT_IMPORTED: {
-		code: "D7016",
-		message: "SQLite storage needs `import '@dialecte/core/sqlite'`",
-		explanation: {
-			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.",
-			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.",
-			docs: `${e}/api/project#sqlite-storage`
+			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`.",
+			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.",
+			docs: `${e}/guide/development/implementing-a-store#register-a-storage-kind`
 		}
 	},
 	DOCUMENT_PATH_INVALID: {
@@ -603,54 +536,47 @@ var e = "https://dialecte.github.io/core", t = {
 			docs: `${e}/api/project#a-document-s-path`
 		}
 	}
-};
+}, r = new Set(Object.values(n).map((e) => e.code));
 // src/errors/errors.ts
-function n(e, t) {
-	throw r(e, t);
+function i(e, t) {
+	throw a(e, t);
 }
-function r(e, n) {
+function a(e, t) {
 	let r = typeof e == "string" ? {
 		key: e,
-		...t[e]
+		...n[e]
 	} : e, i = {
 		code: r.code,
 		key: r.key,
-		message: n.message ?? r.message,
-		detail: n.detail,
+		message: t.message ?? r.message,
+		detail: t.detail,
 		method: l((/* @__PURE__ */ Error()).stack),
-		ref: n.ref,
-		meta: n.meta,
-		cause: n.cause
-	}, a = Error(n.detail);
+		ref: t.ref,
+		meta: t.meta,
+		cause: t.cause
+	}, a = Error(t.detail);
 	return a.cause = i, a;
 }
-function i(e) {
-	let r = {}, i = /* @__PURE__ */ new Map();
+function o(e) {
+	let t = {}, a = /* @__PURE__ */ new Map();
 	for (let [o, s] of Object.entries(e)) {
-		Object.hasOwn(t, o) && n("ASSERTION_FAILED", { detail: `defineErrors: "${o}" is a key of the core catalogue` }), a.has(s.code) && n("ASSERTION_FAILED", { detail: `defineErrors: "${o}" uses "${s.code}", a code of the core catalogue` });
-		let e = i.get(s.code);
-		e && n("ASSERTION_FAILED", { detail: `defineErrors: "${o}" uses "${s.code}", the code of "${e}"` }), i.set(s.code, o), r[o] = {
+		Object.hasOwn(n, o) && i("ASSERTION_FAILED", { detail: `defineErrors: "${o}" is a key of the core catalogue` }), r.has(s.code) && i("ASSERTION_FAILED", { detail: `defineErrors: "${o}" uses "${s.code}", a code of the core catalogue` });
+		let e = a.get(s.code);
+		e && i("ASSERTION_FAILED", { detail: `defineErrors: "${o}" uses "${s.code}", the code of "${e}"` }), a.set(s.code, o), t[o] = {
 			key: o,
 			...s
 		};
 	}
-	return r;
+	return t;
 }
-var a = new Set(Object.values(t).map((e) => e.code));
-function o(e) {
+function s(e) {
 	if (!(e instanceof Error)) return;
 	let t = e.cause;
 	if (!(!t || t instanceof Error) && typeof t.key == "string" && typeof t.code == "string") return t;
 }
-function s(e, n) {
-	return Object.hasOwn(t, e.key) ? !0 : n.catalogues.some((t) => Object.hasOwn(t, e.key) && t[e.key]?.code === e.code);
+function c(e, t) {
+	return Object.hasOwn(n, e.key) ? !0 : t.catalogues.some((t) => Object.hasOwn(t, e.key) && t[e.key]?.code === e.code);
 }
-var c = /* @__PURE__ */ new Set([
-	"throwDialecteError",
-	"createDialecteError",
-	"invariant",
-	"reportFailure"
-]);
 function l(e) {
 	if (!e) return "unknown";
 	let t = e.split("\n").slice(1).map((e) => e.match(/\bat\s+(?:async\s+)?(\S+)(?:\s+\[as\s+[^\]]+\])?\s+\(([^)]+)\)/)).find((e) => !u(e?.[1])), n = t?.[1]?.replace(/^Object\./, ""), r = t?.[2];
@@ -659,7 +585,7 @@ function l(e) {
 	return i ? `${i[1].replace(/\.[^/.]+$/, "")}::${n}` : n;
 }
 function u(e) {
-	return e ? c.has(e.slice(e.lastIndexOf(".") + 1)) : !1;
+	return e ? t.has(e.slice(e.lastIndexOf(".") + 1)) : !1;
 }
 // src/utils/xml-whitespace.constants.ts
 var d = /[ \t\r\n]+/g;
@@ -1062,9 +988,9 @@ function le(e, t = {}) {
 // src/utils/invariant.ts
 function ue(e, t) {
 	if (e) return;
-	let { detail: r, key: i = "ASSERTION_FAILED", ref: a, meta: o } = t;
-	n(i, {
-		detail: r,
+	let { detail: n, key: r = "ASSERTION_FAILED", ref: a, meta: o } = t;
+	i(r, {
+		detail: n,
 		ref: a,
 		meta: o
 	});
@@ -1272,4 +1198,4 @@ function Ce(e) {
 		return t;
 	};
 }
-export { S as A, f as B, k as C, C as D, x as E, te as F, o as G, i as H, ne as I, t as K, ee as L, g as M, _ as N, w as O, b as P, y as R, ae as S, T, s as U, r as V, n as W, R as _, me as a, M as b, pe as c, fe as d, ue as f, L as g, z as h, X as i, v as j, E as k, K as l, B as m, Q as n, q as o, le as p, ye as r, J as s, Ce as t, de as u, I as v, O as w, oe as x, se as y, m as z };
+export { S as A, f as B, k as C, C as D, x as E, te as F, s as G, o as H, ne as I, n as K, ee as L, g as M, _ as N, w as O, b as P, y as R, ae as S, T, c as U, a as V, i as W, R as _, me as a, M as b, pe as c, fe as d, ue as f, L as g, z as h, X as i, v as j, E as k, K as l, B as m, Q as n, q as o, le as p, e as q, ye as r, J as s, Ce as t, de as u, I as v, O as w, oe as x, se as y, m as z };

package/dist/utils.js

@@ -1 +1 @@
-export { C as admittedXsiTypes, T as canonicalXsiType, v as childOccurrences, o as compareQualifiedAttributes, t as createSeededRandomUuid, g as enumeratedValues, y as extractLocalName, p as formatEmbeddedXml, m as formatXml, b as getAttributeRules, f as invariant, s as isNamespaceAllowedByWildcard, x as isSchemaDefaultValue, c as orderAttributesBySequence, a as orderByConfigSequence, i as requiredChoices, w as resolveDefinition, l as resolveNamespaceByPrefix, u as resolveNamespaceByScope, d as resolvePrefixByNamespaceScope, S as resolveSchemaAttributeValue, D as resolveXsiType, r as saveToDisk, _ as valuePatterns } from "./utils-USNkj4sT.js";
+export { C as admittedXsiTypes, T as canonicalXsiType, v as childOccurrences, o as compareQualifiedAttributes, t as createSeededRandomUuid, g as enumeratedValues, y as extractLocalName, p as formatEmbeddedXml, m as formatXml, b as getAttributeRules, f as invariant, s as isNamespaceAllowedByWildcard, x as isSchemaDefaultValue, c as orderAttributesBySequence, a as orderByConfigSequence, i as requiredChoices, w as resolveDefinition, l as resolveNamespaceByPrefix, u as resolveNamespaceByScope, d as resolvePrefixByNamespaceScope, S as resolveSchemaAttributeValue, D as resolveXsiType, r as saveToDisk, _ as valuePatterns } from "./utils-Cv4oHia0.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/core",
-	"version": "0.8.1",
+	"version": "0.10.0",
 	"description": "Dialecte - Core functionality for Dialecte SDK",
 	"license": "MIT",
 	"repository": {
@@ -36,10 +36,6 @@
 			"types": "./dist/helpers.d.ts",
 			"default": "./dist/helpers.js"
 		},
-		"./engine": {
-			"types": "./dist/engine.d.ts",
-			"default": "./dist/engine.js"
-		},
 		"./sqlite": {
 			"types": "./dist/sqlite.d.ts",
 			"default": "./dist/sqlite.js"
@@ -56,9 +52,11 @@
 		"doc:preview": "vitepress preview",
 		"//====== TEST ======//": "",
 		"test": "npm run test:node && npm run test:browser",
-		"test:node": "vitest run --project node --project node-indexeddb --project node-sqlite",
+		"test:node": "vitest run --project node --project node-indexeddb --project node-sqlite --project node-indexeddb-documents",
+		"test:scope": "tsx scripts/test-scope/run-test-scope.ts",
 		"test:browser": "vitest run --project browser",
 		"test:browser:all": "vitest run --project browser-all",
+		"test:browser:release": "STORE_CONTRACT_FULL_TABLE=1 vitest run --project browser-all",
 		"test:perf": "VITE_BENCH=1 vitest run --project perf --mode bench --reporter=verbose",
 		"test:perf:node": "VITE_BENCH=1 vitest run --project perf-node --mode bench --reporter=verbose",
 		"test:hook": "dialecte gate --hook",
@@ -90,7 +88,7 @@
 		"sax": "^1.4.3"
 	},
 	"devDependencies": {
-		"@dialecte/cli": "0.3.1",
+		"@dialecte/cli": "0.4.0",
 		"@tsconfig/node24": "^24.0.4",
 		"@types/node": "^24.12.4",
 		"@typescript/native": "npm:typescript@^7.0.2",
@@ -162,8 +160,42 @@
 				},
 				{
 					"name": "browser tests",
-					"run": "npx vitest run --project browser",
+					"run": "npm run test:scope",
+					"counts": "tests",
+					"scoped": true
+				}
+			],
+			"release": [
+				{
+					"name": "check",
+					"run": "npm run check"
+				},
+				{
+					"name": "skills",
+					"run": "npm run skills:check"
+				},
+				{
+					"name": "build",
+					"run": "npm run build"
+				},
+				{
+					"name": "tests",
+					"run": "npm run test:node",
 					"counts": "tests"
+				},
+				{
+					"name": "browser tests",
+					"run": "npm run test:browser:release",
+					"counts": "tests",
+					"heavy": true
+				},
+				{
+					"name": "type narrowing",
+					"run": "npm run type-narrowing"
+				},
+				{
+					"name": "type bench",
+					"run": "npm run type-bench:check"
 				}
 			]
 		}

package/skills/dialecte/SKILL.md

@@ -21,7 +21,7 @@ uuid/name fix-up that a hook already performs on every write. This skill exists
 
 ```
 your app            custom extensions, services, UI           (yours)
-dialecte package    @dialecte/<id>, @acme/widget              (domain)
+a dialecte package  @dialecte/<id>, @acme/widget              (domain)
   ├ definition/*.generated.ts   generated from the XSD - never edited by hand
   ├ config/                     wires the definition into core, `namespace <Name>` types
   ├ hooks/                      automatic coherence on every write and on import
@@ -237,8 +237,9 @@ doc.query.myFeature.findOrphanParts({ assembly })   // first param is bound away
   (no service, store, composable, component, policy file) and carries none of your product's rules.
   Where your product decides differently from the plain behaviour, see policies below.
 - **Tests on the node tier**: table-driven with the package's runner (`<package>/<version>/test` →
-  `run<Name>TestCases`), inline XML fixtures, the function called directly with `source.query` / `tx`,
-  not through the bound method. No test names a store: the runner runs them in Node on the in-memory
+  `run<Name>TestCases`), whole-document XML fixtures, one call of the unit per test (the function
+  with `source.query` / `tx`, or its bound method; never both), see references/testing.md. No test
+  names a store: the runner runs them in Node on the in-memory
   store. See [Testing](#testing).
 
 ### Policies: your product's choices, passed per call
@@ -289,9 +290,10 @@ composable then imports them with `import type`): do not wrap a type only to re-
 Each dialecte package exports table-driven runners from its `/test` entry
 (`<package>/<version>/test` → `run<Name>TestCases`; core's own: `@dialecte/core/test`). Details
 and the case format: [references/testing.md](references/testing.md). Short version: one table per
-behaviour, inline XML fixtures with `dev:db-id` ids that say intent, `.withExport` asserts the
-resulting XML with XPath, `.withoutExport` asserts inside `act`, `.generic` for pure functions.
-Red first, one case at a time. No test names its store: the runner chooses it (in Node on the
+behaviour, whole-document XML fixtures (inline up to 40 lines, else a sibling `?raw` file) with
+`dev:db-id` ids that say intent, one call of the unit per `act`, `.withExport` asserts the resulting
+XML with hand-written XPath, `.withoutExport` asserts inside `act`, `.generic` for pure functions.
+Refusals assert the error key and nothing staged, never a spy. Red first, one case at a time. No test names its store: the runner chooses it (in Node on the
 in-memory store under a node vitest project whose setup file calls `useTestStorage`, core 0.8+).
 Assertions take XML text; on a big file, check record expectations (tag, attributes, parent,
 count) with the query API instead of XPath on the whole export.