@quillmark/quiver 0.37.0 → 0.38.0

package/README.md

@@ -43,7 +43,7 @@ const quill = await quiver.getQuill(doc.quillRef);
 const result = await engine.render(quill, doc, { format: 'pdf' });
 ```
 
-`getQuill(ref)` is the only way to obtain a quill from a quiver, and the only entry point most consumers need. It accepts selector refs (`"memo"`, `"memo@1"`) and canonical ones (`"memo@1.0.0"`), resolves the selector, materializes the quill via `Quill.fromTree`, and caches one instance per canonical ref for the quiver's lifetime; concurrent calls for the same ref coalesce into a single load. It awaits `init()` itself, so instantiating the core is not a precondition of calling it.
+`getQuill(ref)` is the only way to obtain a quill from a quiver, and the only entry point most consumers need. It accepts selector refs (`"memo"`, `"memo@1.0"`) and canonical ones (`"memo@1.0.0"`), resolves the selector, materializes the quill via `Quill.fromTree`, and caches one instance per canonical ref for the quiver's lifetime; concurrent calls for the same ref coalesce into a single load. It awaits `init()` itself, so instantiating the core is not a precondition of calling it.
 
 That quill is **borrowed, not owned**: every caller asking for that ref gets the same instance, so `free()` on it hands the next caller a freed handle. Code that owns its quill mints one from `(await quiver.getQuill(ref)).toTree()` and frees that.
 
@@ -55,6 +55,10 @@ One narrower verb sits beside `getQuill`: `resolve(ref)` returns the canonical r
 const canonicalRef = quiver.resolve('memo'); // "memo@1.1.0"
 ```
 
+A selector is `x.y` or `x.y.z`. `memo@1.0` is the highest `1.0.z` the quiver holds, and `memo@1.0.0` is exact. `memo@1` is `invalid_ref`: a minor step asks a stored document to be rewritten, so a major alone names no compatible series.
+
+A ref may name the collection, `<quiver>.memo@1.0`, the form a document's `$quill` takes to say which collection it was written for. A quiver answers its own name as it answers the bare one, and refuses any other as `quill_not_found`; the canonical ref is bare.
+
 ## Consuming a quiver (browser)
 
 Build at deploy time, serve the output as static files:
@@ -68,7 +72,7 @@ await build('./node_modules/@org/my-quiver', './public/quivers/my-quiver');
 
 `build` owns its output path outright: it assembles a generation in `<outDir>.stage`, moves it in whole, and deletes the one it replaced. A reader fetching mid-build sees the previous generation rather than a torn tree, and a build that throws leaves it serving. An `outDir` that is, or contains, the source quiver or the working directory is refused with a `transport_error` rather than deleted.
 
-Quills below `0.1.0` are drafts and are left out: they stay in the source layout, which `fromDir` reads whole, and reach the artifact only under `build(src, out, { drafts: true })`. A quill with no version above the floor is absent from the built catalog entirely.
+Quills below `0.1.0` are drafts and are left out: they stay in the source layout, which `fromDir` reads whole, and reach the artifact only under `build(src, out, { drafts: true })`. A quill with no version above the floor is absent from the built catalog entirely. `isDraft(version)`, from `@quillmark/quiver/node`, is the same reading of the floor.
 
 ```ts
 // browser runtime
@@ -149,6 +153,8 @@ my-quiver/
   package.json
 ```
 
+A quill's `Quill.yaml` declares the `quill.name` and `quill.version` of the directory it sits in, the version as `x.y.z`.
+
 A consumer reaches an installed quiver by resolving `<specifier>/Quiver.yaml`, which goes through your `exports` map. A package that declares one must expose that subpath, or the quiver is unreachable however correct its layout; a package with no `exports` map needs nothing.
 
 ```jsonc

package/dist/built-loader.js

@@ -142,13 +142,6 @@ class BuiltLoader {
 function sameFiles(a, b) {
     return a.bundle === b.bundle && JSON.stringify(a.fonts) === JSON.stringify(b.fonts);
 }
-function assertNoUnknownKeys(obj, allowed, context) {
-    for (const key of Object.keys(obj)) {
-        if (!allowed.includes(key)) {
-            throw new QuiverError('quiver_invalid', `${context}: unknown field "${key}"`);
-        }
-    }
-}
 async function readIndex(read) {
     let bytes;
     try {
@@ -175,8 +168,6 @@ function parseIndex(raw) {
         throw new QuiverError('quiver_invalid', `${INDEX} must be a JSON object`);
     }
     const obj = parsed;
-    // Read before the key check, so a newer document is refused as newer rather than as
-    // carrying a field this reader does not know.
     const format = obj['format'];
     if (typeof format !== 'number' || !Number.isInteger(format) || format < 1) {
         throw new QuiverError('quiver_invalid', `${INDEX}: "format" must be a positive integer, got ${JSON.stringify(format)}`);
@@ -185,11 +176,13 @@ function parseIndex(raw) {
         throw new QuiverError('quiver_invalid', `This quiver is built in format ${format} and this loader reads ${FORMAT}. ` +
             `Upgrade @quillmark/quiver, or for a served client the client itself, which carries the copy that reads this.`);
     }
-    assertNoUnknownKeys(obj, ['format', 'name', 'description', 'quills'], INDEX);
     const name = obj['name'];
     if (typeof name !== 'string' || name.length === 0) {
         throw new QuiverError('quiver_invalid', `${INDEX} must have a non-empty string "name" field`);
     }
+    if (!isQuillName(name)) {
+        throw new QuiverError('quiver_invalid', `${INDEX} name "${name}" is not a quill name — a name is [a-z][a-z0-9_]*, at most 64 characters`);
+    }
     const description = obj['description'];
     if (description !== undefined && typeof description !== 'string') {
         throw new QuiverError('quiver_invalid', `${INDEX} "description" must be a string if present, got ${typeof description}`);
@@ -206,13 +199,12 @@ function parseIndex(raw) {
             throw new QuiverError('quiver_invalid', `${at} must be an object`);
         }
         const e = entry;
-        assertNoUnknownKeys(e, ['name', 'version', 'bundle', 'fonts'], at);
         const quillName = e['name'];
         if (typeof quillName !== 'string' || quillName.length === 0) {
             throw new QuiverError('quiver_invalid', `${at}.name must be a non-empty string`);
         }
         if (!isQuillName(quillName)) {
-            throw new QuiverError('quiver_invalid', `${at}.name "${quillName}" is not a name a ref can spell — only [A-Za-z0-9_-] are allowed`);
+            throw new QuiverError('quiver_invalid', `${at}.name "${quillName}" is not a quill name — a name is [a-z][a-z0-9_]*, at most 64 characters`);
         }
         const version = e['version'];
         if (typeof version !== 'string' || !isCanonicalSemver(version)) {

package/dist/format.d.ts

@@ -3,8 +3,9 @@
 export declare const INDEX = "quiver.json";
 /**
  * The artifact's format, stamped into `quiver.json` and refused to be read past (QUIVER
- * §"The index"). Any change a reader assuming the previous shape would misread or reject
- * moves it: `quiver.json` is closed, so an added field is one of those.
+ * §"The index"). A change a reader assuming the previous shape would misread moves it, and
+ * so does the first added field, which format-2 readers before 0.38 refuse; from 3 on, an
+ * added field a reader can skip does not.
  */
 export declare const FORMAT = 2;
 /**

package/dist/format.js

@@ -3,8 +3,9 @@
 export const INDEX = 'quiver.json';
 /**
  * The artifact's format, stamped into `quiver.json` and refused to be read past (QUIVER
- * §"The index"). Any change a reader assuming the previous shape would misread or reject
- * moves it: `quiver.json` is closed, so an added field is one of those.
+ * §"The index"). A change a reader assuming the previous shape would misread moves it, and
+ * so does the first added field, which format-2 readers before 0.38 refuse; from 3 on, an
+ * added field a reader can skip does not.
  */
 export const FORMAT = 2;
 /**

package/dist/node.d.ts

@@ -54,3 +54,4 @@ export { Quiver } from './quiver.js';
 export { QuiverError } from './errors.js';
 export type { QuiverErrorCode } from './errors.js';
 export type { BuildOptions } from './build.js';
+export { isDraft } from './semver.js';

package/dist/node.js

@@ -78,6 +78,7 @@ export async function build(sourceDir, outDir, options) {
 // The rest of the public surface, so a Node consumer needs one import.
 export { Quiver } from './quiver.js';
 export { QuiverError } from './errors.js';
+export { isDraft } from './semver.js';
 // Engine types (`Quillmark`, `Quill`, `Document`, `RenderResult`, …) are not
 // re-exported: import them straight from the `@quillmark/wasm` peer dependency,
 // which is the single source of truth for the engine contract.

package/dist/quiver-yaml.d.ts

@@ -13,7 +13,7 @@ export interface QuiverMeta {
  * Throws `QuiverError('quiver_invalid')` on:
  *   - YAML parse failure
  *   - Missing or non-string `name`
- *   - `name` fails charset validation [A-Za-z0-9_-]+
+ *   - `name` is not a quill name, `[a-z][a-z0-9_]*`
  *   - Unknown fields (strict)
  *   - `description` present but not a string
  */

package/dist/quiver-yaml.js

@@ -13,7 +13,7 @@ const KNOWN_FIELDS = new Set(['name', 'description']);
  * Throws `QuiverError('quiver_invalid')` on:
  *   - YAML parse failure
  *   - Missing or non-string `name`
- *   - `name` fails charset validation [A-Za-z0-9_-]+
+ *   - `name` is not a quill name, `[a-z][a-z0-9_]*`
  *   - Unknown fields (strict)
  *   - `description` present but not a string
  */
@@ -43,7 +43,7 @@ export function parseQuiverYaml(raw) {
     }
     const name = doc['name'];
     if (!isQuillName(name)) {
-        throw new QuiverError('quiver_invalid', `Quiver.yaml: "name" value "${name}" contains invalid characters — only [A-Za-z0-9_-] are allowed`);
+        throw new QuiverError('quiver_invalid', `Quiver.yaml: "name" value "${name}" is not a quill name — a name is [a-z][a-z0-9_]*, at most 64 characters`);
     }
     const meta = { name };
     if (doc['description'] !== undefined) {

package/dist/quiver.d.ts

@@ -64,8 +64,10 @@ export declare class Quiver {
     /**
      * Resolves a selector ref → canonical ref (e.g. "memo" → "memo@1.1.0").
      *
-     * Selector forms: `name`, `name@x`, `name@x.y`, `name@x.y.z`. Picks the
-     * highest matching version in this quiver.
+     * Selector forms: `name`, `name@x.y`, `name@x.y.z`. Picks the highest
+     * matching version in this quiver. A name prefixed with this quiver's
+     * own name (`<quiver>.name`) resolves as the bare name does; one prefixed with
+     * any other collection is `quill_not_found`. The canonical ref is bare.
      *
      * Sync, and in-memory by construction rather than by implementation: every
      * loader materializes the catalog as the quiver is built, and `QuiverLoader`
@@ -85,7 +87,7 @@ export declare class Quiver {
      *
      * A core `Quill` renders directly: pass it to `engine.render(quill, doc)`.
      *
-     * Selector refs (e.g. `"memo"`, `"memo@1"`) are resolved to canonical form
+     * Selector refs (e.g. `"memo"`, `"memo@1.0"`) are resolved to canonical form
      * first. Materializes once and caches per canonical ref — concurrent calls
      * coalesce into a single load.
      *

package/dist/quiver.js

@@ -92,8 +92,10 @@ export class Quiver {
     /**
      * Resolves a selector ref → canonical ref (e.g. "memo" → "memo@1.1.0").
      *
-     * Selector forms: `name`, `name@x`, `name@x.y`, `name@x.y.z`. Picks the
-     * highest matching version in this quiver.
+     * Selector forms: `name`, `name@x.y`, `name@x.y.z`. Picks the highest
+     * matching version in this quiver. A name prefixed with this quiver's
+     * own name (`<quiver>.name`) resolves as the bare name does; one prefixed with
+     * any other collection is `quill_not_found`. The canonical ref is bare.
      *
      * Sync, and in-memory by construction rather than by implementation: every
      * loader materializes the catalog as the quiver is built, and `QuiverLoader`
@@ -104,8 +106,8 @@ export class Quiver {
      *   - `quill_not_found` if no version matches
      */
     resolve(ref) {
-        const { name, selector } = parseQuillRef(ref);
-        const versions = this.#catalog.get(name);
+        const { collection, name, selector } = parseQuillRef(ref);
+        const versions = collection === undefined || collection === this.name ? this.#catalog.get(name) : undefined;
         if (versions !== undefined) {
             // Every loader materializes a catalog sorted descending, so the first match is
             // the highest.
@@ -126,7 +128,7 @@ export class Quiver {
      *
      * A core `Quill` renders directly: pass it to `engine.render(quill, doc)`.
      *
-     * Selector refs (e.g. `"memo"`, `"memo@1"`) are resolved to canonical form
+     * Selector refs (e.g. `"memo"`, `"memo@1.0"`) are resolved to canonical form
      * first. Materializes once and caches per canonical ref — concurrent calls
      * coalesce into a single load.
      *

package/dist/ref.d.ts

@@ -1,18 +1,20 @@
 /** Internal parsed representation of a quill reference. */
 export interface ParsedQuillRef {
+    /** The collection the ref names, the part before a `.`; absent on a bare name. */
+    collection?: string;
     name: string;
     /** Undefined selects the highest version present. */
     selector?: string;
 }
 /**
- * Whether `name` is a name a ref can spell. A quiver's own name and every catalog
- * row are held to it: a row seated outside it is one `quillNames` lists and
- * `getQuill` refuses.
+ * Whether `name` is a quill name: `[a-z][a-z0-9_]*`, at most 64 characters, the
+ * engine's rule. A quiver's own name and every catalog row are held to it.
  */
 export declare function isQuillName(name: string): boolean;
 /**
- * Throws QuiverError('invalid_ref') on malformed input. The name is
- * `[A-Za-z0-9_-]+`; the selector is `x`, `x.y` or `x.y.z`, digits only, with no
- * ranges or operators — a quiver resolves a prefix, it does not solve a range.
+ * Throws QuiverError('invalid_ref') on malformed input. The name is a quill name,
+ * optionally prefixed `<collection>.`; the selector is `x.y` or `x.y.z`, digits
+ * only, with no ranges or operators — a quiver resolves a prefix, it does not
+ * solve a range.
  */
 export declare function parseQuillRef(ref: string): ParsedQuillRef;

package/dist/ref.js

@@ -1,18 +1,18 @@
 import { QuiverError } from './errors.js';
-const NAME_RE = /^[A-Za-z0-9_-]+$/;
-const SELECTOR_RE = /^\d+(\.\d+){0,2}$/;
+const NAME_RE = /^[a-z][a-z0-9_]{0,63}$/;
+const SELECTOR_RE = /^\d+\.\d+(\.\d+)?$/;
 /**
- * Whether `name` is a name a ref can spell. A quiver's own name and every catalog
- * row are held to it: a row seated outside it is one `quillNames` lists and
- * `getQuill` refuses.
+ * Whether `name` is a quill name: `[a-z][a-z0-9_]*`, at most 64 characters, the
+ * engine's rule. A quiver's own name and every catalog row are held to it.
  */
 export function isQuillName(name) {
     return NAME_RE.test(name);
 }
 /**
- * Throws QuiverError('invalid_ref') on malformed input. The name is
- * `[A-Za-z0-9_-]+`; the selector is `x`, `x.y` or `x.y.z`, digits only, with no
- * ranges or operators — a quiver resolves a prefix, it does not solve a range.
+ * Throws QuiverError('invalid_ref') on malformed input. The name is a quill name,
+ * optionally prefixed `<collection>.`; the selector is `x.y` or `x.y.z`, digits
+ * only, with no ranges or operators — a quiver resolves a prefix, it does not
+ * solve a range.
  */
 export function parseQuillRef(ref) {
     if (!ref) {
@@ -24,21 +24,30 @@ export function parseQuillRef(ref) {
     }
     // Split once: the charset the name is held to is one rule, and a ref with a selector
     // is under it exactly as a bare one is.
-    const name = atIndex === -1 ? ref : ref.slice(0, atIndex);
+    const fullName = atIndex === -1 ? ref : ref.slice(0, atIndex);
     const selector = atIndex === -1 ? undefined : ref.slice(atIndex + 1);
     if (selector === '') {
         throw new QuiverError('invalid_ref', `Invalid ref: missing selector after "@" in "${ref}"`, {
             ref
         });
     }
-    if (!NAME_RE.test(name)) {
-        throw new QuiverError('invalid_ref', `Invalid ref: name "${name}" contains invalid characters`, { ref });
+    const dot = fullName.indexOf('.');
+    const collection = dot === -1 ? undefined : fullName.slice(0, dot);
+    const name = dot === -1 ? fullName : fullName.slice(dot + 1);
+    for (const segment of collection === undefined ? [name] : [collection, name]) {
+        if (!NAME_RE.test(segment)) {
+            throw new QuiverError('invalid_ref', `Invalid ref: name "${fullName}" is not [collection.]name, each [a-z][a-z0-9_]* and at most 64 characters`, { ref });
+        }
     }
+    const parsed = collection === undefined ? { name } : { collection, name };
     if (selector === undefined) {
-        return { name };
+        return parsed;
+    }
+    if (/^\d+$/.test(selector)) {
+        throw new QuiverError('invalid_ref', `Invalid ref: selector "${selector}" is a major alone, which names no compatible series; write "${fullName}@${selector}.y" or "${fullName}@${selector}.y.z"`, { ref });
     }
     if (!SELECTOR_RE.test(selector)) {
-        throw new QuiverError('invalid_ref', `Invalid ref: selector "${selector}" is not a valid semver selector (only x, x.y, x.y.z with digits allowed)`, { ref });
+        throw new QuiverError('invalid_ref', `Invalid ref: selector "${selector}" is not x.y (a compatible series) or x.y.z (an exact version), digits only`, { ref });
     }
-    return { name, selector };
+    return { ...parsed, selector };
 }

package/dist/semver.d.ts

@@ -3,9 +3,9 @@ export declare const MIN_PUBLISHED_VERSION = "0.1.0";
 /** Returns true for exactly `x.y.z` with non-negative integer parts. */
 export declare function isCanonicalSemver(version: string): boolean;
 /**
- * Returns true if `version` (canonical) matches `selector` (partial: `x`,
- * `x.y`, or `x.y.z`). `parseQuillRef` owns selector validation; this is a
- * prefix comparison over an already-valid selector.
+ * Returns true if `version` (canonical) matches `selector` (`x.y` or `x.y.z`).
+ * `parseQuillRef` owns selector validation; this is a prefix comparison over an
+ * already-valid selector.
  */
 export declare function matchesSemverSelector(version: string, selector: string): boolean;
 /** Compares two canonical semver strings. Returns <0, 0, or >0. Three positions,

package/dist/semver.js

@@ -5,9 +5,9 @@ export function isCanonicalSemver(version) {
     return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version);
 }
 /**
- * Returns true if `version` (canonical) matches `selector` (partial: `x`,
- * `x.y`, or `x.y.z`). `parseQuillRef` owns selector validation; this is a
- * prefix comparison over an already-valid selector.
+ * Returns true if `version` (canonical) matches `selector` (`x.y` or `x.y.z`).
+ * `parseQuillRef` owns selector validation; this is a prefix comparison over an
+ * already-valid selector.
  */
 export function matchesSemverSelector(version, selector) {
     const selectorParts = selector.split('.');

package/dist/source-loader.d.ts

@@ -12,9 +12,9 @@ import type { QuiverLoader } from './quiver.js';
  *
  * Throws:
  *   - `quiver_invalid` if Quiver.yaml is invalid, any rung it opens or reads is a
- *     symlink, a quill dir holding versions is named outside the ref charset, a
- *     version dir name is non-canonical, or a version dir is missing its Quill.yaml
- *     sentinel.
+ *     symlink, a quill dir holding versions is not a quill name, a version dir
+ *     name is non-canonical, or a version dir is missing its Quill.yaml or holds
+ *     one naming another quill or version.
  *   - `transport_error` for I/O failures (permissions, etc.).
  *
  * Missing `quills/` directory is not an error — the quiver is valid but empty.

package/dist/source-loader.js

@@ -4,6 +4,7 @@
  */
 import { readdir, readFile, lstat } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
+import { parse as parseYaml } from 'yaml';
 import { QuiverError } from './errors.js';
 import { parseQuiverYaml } from './quiver-yaml.js';
 import { isQuillName } from './ref.js';
@@ -20,6 +21,44 @@ function refuseSymlink(st, path) {
         throw new QuiverError('quiver_invalid', `"${path}" is a symlink; a quiver holds its own content, and nothing under it may point outside`);
     }
 }
+/**
+ * Asked of a directory holding a quill rather than of every directory, so a stray
+ * one holding none stays ignored: what has to be addressable is a catalog row.
+ */
+function refuseUnnamedQuill(quillName, quiverName) {
+    if (!isQuillName(quillName)) {
+        throw new QuiverError('quiver_invalid', `Quill directory "${quillName}" is not a quill name — a name is [a-z][a-z0-9_]*, at most 64 characters`, { quiverName });
+    }
+}
+/**
+ * Refuse a `Quill.yaml` whose `quill.name` or `quill.version` disagrees with the
+ * path it sits at: the catalog serves the path, and a document saved from the quill
+ * names what `Quill.yaml` says. A canonical version has one spelling, so the declared
+ * one is compared as written. A field absent or not a string is the engine's to report
+ * when the quill loads.
+ */
+function refuseMisplacedQuill(raw, name, version, quiverName) {
+    let parsed;
+    try {
+        parsed = parseYaml(new TextDecoder().decode(raw), { schema: 'failsafe' });
+    }
+    catch {
+        return;
+    }
+    const quill = parsed?.quill;
+    if (typeof quill !== 'object' || quill === null)
+        return;
+    const declared = quill;
+    if (typeof declared.name === 'string' && declared.name !== name) {
+        throw new QuiverError('quiver_invalid', `Quill "${name}@${version}" declares quill.name "${declared.name}": a quill sits at quills/<quill.name>/<quill.version>/`, { quiverName, version });
+    }
+    if (typeof declared.version === 'string' && declared.version !== version) {
+        const rule = isCanonicalSemver(declared.version)
+            ? 'a quill sits at quills/<quill.name>/<quill.version>/'
+            : 'a quill version is x.y.z';
+        throw new QuiverError('quiver_invalid', `Quill "${name}@${version}" declares quill.version "${declared.version}": ${rule}`, { quiverName, version });
+    }
+}
 /**
  * Scans a Source Quiver root directory.
  *
@@ -28,9 +67,9 @@ function refuseSymlink(st, path) {
  *
  * Throws:
  *   - `quiver_invalid` if Quiver.yaml is invalid, any rung it opens or reads is a
- *     symlink, a quill dir holding versions is named outside the ref charset, a
- *     version dir name is non-canonical, or a version dir is missing its Quill.yaml
- *     sentinel.
+ *     symlink, a quill dir holding versions is not a quill name, a version dir
+ *     name is non-canonical, or a version dir is missing its Quill.yaml or holds
+ *     one naming another quill or version.
  *   - `transport_error` for I/O failures (permissions, etc.).
  *
  * Missing `quills/` directory is not an error — the quiver is valid but empty.
@@ -106,8 +145,10 @@ export async function scanSourceQuiver(rootDir) {
                 throw new QuiverError('quiver_invalid', `Quill "${quillName}" has non-canonical version directory "${versionDir}" — only x.y.z format is allowed`, { quiverName: meta.name, version: versionDir });
             }
             const quillYamlPath = join(versionPath, 'Quill.yaml');
+            let quillYaml;
             try {
                 refuseSymlink(await lstat(quillYamlPath), quillYamlPath);
+                quillYaml = await readFile(quillYamlPath);
             }
             catch (err) {
                 if (err instanceof QuiverError)
@@ -116,16 +157,13 @@ export async function scanSourceQuiver(rootDir) {
                 if (code === 'ENOENT') {
                     throw new QuiverError('quiver_invalid', `Quill "${quillName}@${versionDir}" is missing required "Quill.yaml"`, { quiverName: meta.name, version: versionDir });
                 }
-                throw new QuiverError('transport_error', `Failed to stat "Quill.yaml" at "${quillYamlPath}": ${err.message}`, { cause: err });
+                throw new QuiverError('transport_error', `Failed to read "Quill.yaml" at "${quillYamlPath}": ${err.message}`, { cause: err });
             }
+            refuseUnnamedQuill(quillName, meta.name);
+            refuseMisplacedQuill(quillYaml, quillName, versionDir, meta.name);
             versions.push(versionDir);
         }
         if (versions.length > 0) {
-            // Asked here rather than at the directory, so a stray one holding no quill
-            // stays ignored: what has to be addressable is a catalog row.
-            if (!isQuillName(quillName)) {
-                throw new QuiverError('quiver_invalid', `Quill directory "${quillName}" is not a name a ref can spell — only [A-Za-z0-9_-] are allowed`, { quiverName: meta.name });
-            }
             versions.sort((a, b) => compareSemver(b, a));
             catalog.set(quillName, versions);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/quiver",
-	"version": "0.37.0",
+	"version": "0.38.0",
 	"description": "A quiver of Quillmark quills: load one, pack one, hand out quills.",
 	"type": "module",
 	"license": "Apache-2.0",
@@ -21,7 +21,7 @@
 	],
 	"author": "Quillmark Contributors",
 	"engines": {
-		"node": ">=24"
+		"node": ">=22"
 	},
 	"exports": {
 		".": {
@@ -42,7 +42,7 @@
 		"NOTICE"
 	],
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.125.0-0"
+		"@quillmark/wasm": ">=0.126.0-0"
 	},
 	"dependencies": {
 		"fflate": "^0.8.2",