zarr-metadata 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davis Bennett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# zarr-metadata (TypeScript)
+
+Spec-defined metadata types and structural validators for
+[Zarr](https://zarr.dev) v2 and v3, in TypeScript. A port of the Python
+[`zarr-metadata`](https://pypi.org/project/zarr-metadata/) package (the
+reference implementation), kept in lockstep by a shared conformance corpus.
+
+```ts
+import {
+  validateMetadataV3,
+  safeParseArrayMetadataV2,
+  isEmptyTree,
+  flattenTree,
+} from "zarr-metadata";
+
+// Validation produces a tree of errors mirroring the document's shape;
+// an empty tree means the document is valid.
+const errors = validateMetadataV3(JSON.parse(text));
+if (!isEmptyTree(errors)) {
+  errors.children.get("codecs"); // the subtree of codec problems
+  flattenTree(errors); // the flat view, for diagnostics:
+  // [{ path: ["codecs"], kind: "invalid_value", message: "expected at least one codec" }]
+}
+
+// Or the discriminated-union form:
+const result = safeParseArrayMetadataV2(JSON.parse(zarrayText));
+if (result.success) {
+  result.value.shape; // typed as ZarrV2ArrayMetadataJSON
+} else {
+  result.errors; // the ErrorTree
+}
+```
+
+Each document kind gets four entry points:
+
+- `validate*(value)` → `ErrorTree` (empty tree means valid)
+- `safeParse*(value)` → `{ success: true, value } | { success: false, errors }`
+- `is*(value)` → type guard
+- `parse*(value)` → narrowed document or throws `MetadataValidationError`
+  (which carries the tree as `.errors` and its flat view as `.issues`)
+
+## Standard Schema
+
+Every document kind is also exported as a
+[Standard Schema](https://standardschema.dev) — the interop contract
+implemented by Zod, Valibot, and ArkType — so the validators plug directly
+into anything that accepts standard schemas (tRPC, form libraries, ...):
+
+```ts
+import { metadataV3Schema, type StandardSchemaV1 } from "zarr-metadata";
+
+const result = await metadataV3Schema["~standard"].validate(JSON.parse(text));
+if (result.issues === undefined) {
+  result.value; // ZarrV3ArrayMetadataJSON | ZarrV3GroupMetadataJSON
+}
+type Doc = StandardSchemaV1.InferOutput<typeof metadataV3Schema>;
+```
+
+Validation is synchronous; each issue keeps its machine-readable `kind` as
+a spec-permitted extension. The schemas are `jsonValueSchema`,
+`metadataFieldV3Schema`, `{array,group,consolidated}MetadataV3Schema`,
+`metadataV3Schema` (the `zarr.json` dispatcher), and
+`{array,group,consolidated}MetadataV2Schema`. The spec types are vendored
+(the package stays dependency-free); the test suite pins them against the
+official `@standard-schema/spec` package.
+
+Covered documents: v3 array/group (`zarr.json`, including inline
+`consolidated_metadata`), v2 array/group merged forms (`.zarray` /
+`.zgroup` + `.zattrs`), and v2 consolidated metadata (`.zmetadata`).
+The `MetadataV3` family dispatches on `node_type` for consumers handed an
+arbitrary `zarr.json`.
+
+The error-tree shape follows TypeScript validation-library convention
+(compare Zod's `treeifyError` and `safeParse`) rather than the Python
+package's flat problem lists; `flattenTree`/`treeOf` convert between the
+two, and the flat path+kind form remains the cross-language interchange
+format the conformance corpus asserts on.
+
+Validation is structural (key presence, value shapes, fixed literals), not
+domain-level: extension points (codecs, chunk grids, data types) are never
+interpreted, matching the Python package's layering.
+
+Consumers include the
+[Zarr Metadata VS Code extension](https://github.com/d-v-b/vscode-zarr).
+
+## How correctness is maintained
+
+The [conformance corpus](conformance/) is the contract with the Python
+reference implementation: shared JSON fixtures asserting the exact problem
+set (loc + kind) each document must produce. Both test suites run every
+case; a spec change updates the corpus first, turning both implementations
+red until each is fixed.
+
+## Development
+
+Development verbs live in the [justfile](justfile) (needs
+[`just`](https://github.com/casey/just), plus `uv` for the conformance
+recipe); `just` with no arguments lists them:
+
+```bash
+just install       # npm install
+just build         # tsc → dist/
+just test          # vitest: conformance corpus + unit tests
+just typecheck     # sources and tests, including type-level assertions
+just conformance   # corpus vs the Python reference (PyPI by default)
+just check         # everything CI runs
+```
+
+`just conformance ../zarr-python/packages/zarr-metadata` runs the corpus
+against a local zarr-python checkout instead of the released PyPI package.
+Each recipe wraps a plain npm/uv command, so `just` itself is optional.
+
+Releases are changeset-driven; see [RELEASING.md](RELEASING.md).

package/dist/common.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Cross-version primitives for Zarr metadata.
+ *
+ * This package is a TypeScript port of the Python `zarr-metadata` package
+ * (https://pypi.org/project/zarr-metadata/), which is the reference
+ * implementation. The two are kept in lockstep by a shared conformance
+ * corpus; see `conformance/` at the repository root.
+ */
+/** A JSON-encodable value. */
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+/**
+ * Externally-tagged union member for a v3 metadata field.
+ *
+ * The optional `configuration` mapping holds arbitrary JSON-encodable
+ * values. `must_understand` is implicitly true when absent.
+ */
+export type ZarrV3NamedConfigJSON = {
+    name: string;
+    configuration?: {
+        [key: string]: JSONValue;
+    };
+    must_understand?: boolean;
+};
+/**
+ * The JSON shape of any v3 metadata extension-point entry: either a bare
+ * short-hand name string or a `{name, configuration, must_understand}`
+ * envelope.
+ *
+ * Used for `data_type`, `chunk_grid`, `chunk_key_encoding`, individual
+ * codec entries, and `storage_transformers` in v3 array metadata.
+ */
+export type ZarrV3MetadataFieldJSON = string | ZarrV3NamedConfigJSON;
+//# sourceMappingURL=common.d.ts.map

package/dist/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,8BAA8B;AAC9B,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,qBAAqB,CAAC"}

package/dist/common.js

@@ -0,0 +1,10 @@
+/**
+ * Cross-version primitives for Zarr metadata.
+ *
+ * This package is a TypeScript port of the Python `zarr-metadata` package
+ * (https://pypi.org/project/zarr-metadata/), which is the reference
+ * implementation. The two are kept in lockstep by a shared conformance
+ * corpus; see `conformance/` at the repository root.
+ */
+export {};
+//# sourceMappingURL=common.js.map

package/dist/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/errors.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The error vocabulary: validation produces a tree of issues mirroring the
+ * document's shape, and an empty tree means the document is valid.
+ *
+ * This shape is native to TypeScript validation libraries (compare Zod's
+ * `treeifyError` and `safeParse`) rather than ported from the Python
+ * reference implementation, which returns a flat list of loc-tagged
+ * problems. The two are isomorphic: `flattenTree` produces the flat
+ * path+kind form — the interchange format the cross-language conformance
+ * corpus asserts on, and the form editor tooling needs to place a
+ * diagnostic at a document location — and `treeOf` rebuilds a tree from it.
+ *
+ * Invariant: a subtree exists only on the path to at least one issue, so
+ * `isEmptyTree` never has to search — an empty root IS the success case.
+ */
+/**
+ * Machine-readable classification of an issue.
+ *
+ * - `missing_key`: a required key (document key or store key) is absent.
+ * - `invalid_type`: a value has the wrong structural type (e.g. a string
+ *   where a mapping is required).
+ * - `invalid_value`: a value has an acceptable type but invalid content
+ *   (e.g. `zarr_format: 2` in a v3 document, `order: "Q"`).
+ * - `invalid_json`: bytes/text that do not decode as JSON.
+ */
+export type IssueKind = "missing_key" | "invalid_type" | "invalid_value" | "invalid_json";
+/** One problem, attached to the tree node whose document location it describes. */
+export interface Issue {
+    readonly kind: IssueKind;
+    readonly message: string;
+}
+/**
+ * The path from the document root to a value: object keys and array
+ * indices, e.g. `["codecs", 0, "name"]`. Empty means the document itself.
+ */
+export type IssuePath = ReadonlyArray<string | number>;
+/** An issue paired with its full path — the flat view of a tree entry. */
+export interface PathedIssue extends Issue {
+    readonly path: IssuePath;
+}
+/**
+ * Every problem found in a document, arranged as a tree mirroring the
+ * document's own shape: `issues` holds the problems at this location, and
+ * `children` (keyed by object key or array index) holds the problems below
+ * it. An empty tree — no issues, no children — means validation succeeded.
+ *
+ * `children` is a `Map` so array indices keep their number identity
+ * instead of collapsing into string keys.
+ */
+export interface ErrorTree {
+    readonly issues: ReadonlyArray<Issue>;
+    readonly children: ReadonlyMap<string | number, ErrorTree>;
+}
+/** Whether `tree` holds no issues anywhere — the success verdict. */
+export declare function isEmptyTree(tree: ErrorTree): boolean;
+/** Build an `ErrorTree` from flat pathed issues (the inverse of `flattenTree`). */
+export declare function treeOf(issues: ReadonlyArray<PathedIssue>): ErrorTree;
+/**
+ * The flat view of `tree`: every issue with its full path, parents before
+ * children. This is the interchange form — what the conformance corpus
+ * asserts on, and what a consumer placing diagnostics in a text document
+ * wants.
+ */
+export declare function flattenTree(tree: ErrorTree): PathedIssue[];
+/** Render `tree` as one human-readable line per issue (`"path.to.value: message"`). */
+export declare function formatTree(tree: ErrorTree): string;
+/**
+ * The result of a `safeParse*` function: the narrowed document on success,
+ * the error tree on failure.
+ */
+export type ParseResult<T> = {
+    readonly success: true;
+    readonly value: T;
+} | {
+    readonly success: false;
+    readonly errors: ErrorTree;
+};
+/**
+ * Thrown by `parse*` functions and the store entry points when a value
+ * fails validation. Carries the complete error tree (not just the first
+ * problem) as `.errors`, with `.issues` as its flat view.
+ */
+export declare class MetadataValidationError extends Error {
+    readonly errors: ErrorTree;
+    readonly issues: ReadonlyArray<PathedIssue>;
+    constructor(errors: ErrorTree);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,cAAc,GAAG,eAAe,GAAG,cAAc,CAAC;AAE1F,mFAAmF;AACnF,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AAEvD,0EAA0E;AAC1E,MAAM,WAAW,WAAY,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,GAAG,MAAM,EAAE,SAAS,CAAC,CAAC;CAC5D;AAED,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEpD;AAOD,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,SAAS,CAepE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,EAAE,CAY1D;AAOD,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAElD;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IACrB;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAE5D;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;gBAEhC,MAAM,EAAE,SAAS;CAO9B"}

package/dist/errors.js

@@ -0,0 +1,80 @@
+/**
+ * The error vocabulary: validation produces a tree of issues mirroring the
+ * document's shape, and an empty tree means the document is valid.
+ *
+ * This shape is native to TypeScript validation libraries (compare Zod's
+ * `treeifyError` and `safeParse`) rather than ported from the Python
+ * reference implementation, which returns a flat list of loc-tagged
+ * problems. The two are isomorphic: `flattenTree` produces the flat
+ * path+kind form — the interchange format the cross-language conformance
+ * corpus asserts on, and the form editor tooling needs to place a
+ * diagnostic at a document location — and `treeOf` rebuilds a tree from it.
+ *
+ * Invariant: a subtree exists only on the path to at least one issue, so
+ * `isEmptyTree` never has to search — an empty root IS the success case.
+ */
+/** Whether `tree` holds no issues anywhere — the success verdict. */
+export function isEmptyTree(tree) {
+    return tree.issues.length === 0 && tree.children.size === 0;
+}
+/** Build an `ErrorTree` from flat pathed issues (the inverse of `flattenTree`). */
+export function treeOf(issues) {
+    const root = { issues: [], children: new Map() };
+    for (const { path, kind, message } of issues) {
+        let node = root;
+        for (const part of path) {
+            let child = node.children.get(part);
+            if (child === undefined) {
+                child = { issues: [], children: new Map() };
+                node.children.set(part, child);
+            }
+            node = child;
+        }
+        node.issues.push({ kind, message });
+    }
+    return root;
+}
+/**
+ * The flat view of `tree`: every issue with its full path, parents before
+ * children. This is the interchange form — what the conformance corpus
+ * asserts on, and what a consumer placing diagnostics in a text document
+ * wants.
+ */
+export function flattenTree(tree) {
+    const out = [];
+    const walk = (node, path) => {
+        for (const issue of node.issues) {
+            out.push({ path, kind: issue.kind, message: issue.message });
+        }
+        for (const [part, child] of node.children) {
+            walk(child, [...path, part]);
+        }
+    };
+    walk(tree, []);
+    return out;
+}
+function formatPathedIssue(issue) {
+    const location = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${location}: ${issue.message}`;
+}
+/** Render `tree` as one human-readable line per issue (`"path.to.value: message"`). */
+export function formatTree(tree) {
+    return flattenTree(tree).map(formatPathedIssue).join("\n");
+}
+/**
+ * Thrown by `parse*` functions and the store entry points when a value
+ * fails validation. Carries the complete error tree (not just the first
+ * problem) as `.errors`, with `.issues` as its flat view.
+ */
+export class MetadataValidationError extends Error {
+    errors;
+    issues;
+    constructor(errors) {
+        const issues = flattenTree(errors);
+        super(issues.map(formatPathedIssue).join("\n"));
+        this.name = "MetadataValidationError";
+        this.errors = errors;
+        this.issues = issues;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * zarr-metadata: spec-defined metadata types and validators for Zarr v2 and
+ * v3, in TypeScript.
+ *
+ * A port of the Python `zarr-metadata` package (the reference
+ * implementation), kept in lockstep by a shared conformance corpus.
+ */
+export type { JSONValue, ZarrV3MetadataFieldJSON, ZarrV3NamedConfigJSON } from "./common.js";
+export { flattenTree, formatTree, isEmptyTree, MetadataValidationError, treeOf, type ErrorTree, type Issue, type IssueKind, type IssuePath, type ParseResult, type PathedIssue, } from "./errors.js";
+export * from "./schemas.js";
+export type { StandardSchemaV1 } from "./standard-schema.js";
+export * from "./v2.js";
+export * from "./v3.js";
+export * from "./validation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EAAE,SAAS,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,MAAM,EACN,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,GACjB,MAAM,aAAa,CAAC;AACrB,cAAc,cAAc,CAAC;AAC7B,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * zarr-metadata: spec-defined metadata types and validators for Zarr v2 and
+ * v3, in TypeScript.
+ *
+ * A port of the Python `zarr-metadata` package (the reference
+ * implementation), kept in lockstep by a shared conformance corpus.
+ */
+export { flattenTree, formatTree, isEmptyTree, MetadataValidationError, treeOf, } from "./errors.js";
+export * from "./schemas.js";
+export * from "./v2.js";
+export * from "./v3.js";
+export * from "./validation.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,MAAM,GAOP,MAAM,aAAa,CAAC;AACrB,cAAc,cAAc,CAAC;AAE7B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC"}

package/dist/keys.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Compile-time machinery tying the runtime key arrays to the document types.
+ *
+ * The validators need key names at runtime, and TypeScript types are erased,
+ * so the arrays in v2.ts / v3.ts cannot be derived from the types the way
+ * the Python package derives its key sets from `__required_keys__`. What the
+ * type system CAN do is the reverse: prove each array is exactly the set of
+ * required (or optional) keys declared by the document type, so the two can
+ * never drift.
+ */
+/**
+ * The declared properties of `T`, with index signatures stripped.
+ *
+ * The v3 document types carry a `[key: string]: ...` index signature for
+ * extension fields; without stripping it, `keyof` collapses to `string` and
+ * the per-key extraction below would be meaningless.
+ */
+type Known<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+/** The union of `T`'s required declared keys. */
+export type RequiredKeysOf<T> = {
+    [K in keyof Known<T>]-?: {} extends Pick<Known<T>, K> ? never : K;
+}[keyof Known<T>];
+/** The union of `T`'s optional declared keys. */
+export type OptionalKeysOf<T> = {
+    [K in keyof Known<T>]-?: {} extends Pick<Known<T>, K> ? K : never;
+}[keyof Known<T>];
+/**
+ * Identity for a readonly tuple of keys, statically checked to be EXACTLY
+ * the union `U`: the element constraint rejects keys outside `U`, and the
+ * intersected conditional rejects the tuple when any member of `U` is
+ * missing (surfacing as a "not assignable" error on the argument).
+ *
+ * Usage: `exactKeys<RequiredKeysOf<Doc>>()(["a", "b"])`.
+ */
+export declare function exactKeys<U extends PropertyKey>(): <const A extends readonly U[]>(keys: A & ([U] extends [A[number]] ? unknown : never)) => A;
+export {};
+//# sourceMappingURL=keys.d.ts.map

package/dist/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,KAAK,KAAK,CAAC,CAAC,IAAI;KACb,CAAC,IAAI,MAAM,CAAC,IAAI,MAAM,SAAS,CAAC,GAAG,KAAK,GAAG,MAAM,SAAS,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAChF,CAAC;AAEF,iDAAiD;AACjD,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC;CAClE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAElB,iDAAiD;AACjD,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAClE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAElB;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,MACrC,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,EAAE,EAClC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC,KACpD,CAAC,CACL"}

package/dist/keys.js

@@ -0,0 +1,22 @@
+/**
+ * Compile-time machinery tying the runtime key arrays to the document types.
+ *
+ * The validators need key names at runtime, and TypeScript types are erased,
+ * so the arrays in v2.ts / v3.ts cannot be derived from the types the way
+ * the Python package derives its key sets from `__required_keys__`. What the
+ * type system CAN do is the reverse: prove each array is exactly the set of
+ * required (or optional) keys declared by the document type, so the two can
+ * never drift.
+ */
+/**
+ * Identity for a readonly tuple of keys, statically checked to be EXACTLY
+ * the union `U`: the element constraint rejects keys outside `U`, and the
+ * intersected conditional rejects the tuple when any member of `U` is
+ * missing (surfacing as a "not assignable" error on the argument).
+ *
+ * Usage: `exactKeys<RequiredKeysOf<Doc>>()(["a", "b"])`.
+ */
+export function exactKeys() {
+    return (keys) => keys;
+}
+//# sourceMappingURL=keys.js.map

package/dist/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAuBH;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,CACL,IAAqD,EAClD,EAAE,CAAC,IAAI,CAAC;AACf,CAAC"}

package/dist/schemas.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Standard Schema (https://standardschema.dev) objects for every document
+ * kind, so the validators plug into anything that accepts standard schemas
+ * (tRPC, form libraries, ...).
+ *
+ * Each schema wraps the corresponding `safeParse*` function: validation is
+ * synchronous, success carries the narrowed document, and failure carries
+ * the flattened error tree as standard issues. Every issue additionally
+ * keeps its machine-readable `kind` (an extension the standard permits);
+ * consumers wanting the full `ErrorTree` should use `validate*` directly.
+ */
+import { type IssueKind } from "./errors.js";
+import type { JSONValue, ZarrV3MetadataFieldJSON } from "./common.js";
+import type { StandardSchemaV1 } from "./standard-schema.js";
+import type { ZarrV2ArrayMetadataJSON, ZarrV2ConsolidatedMetadataJSON, ZarrV2GroupMetadataJSON } from "./v2.js";
+import type { ZarrV3ArrayMetadataJSON, ZarrV3ConsolidatedMetadataJSON, ZarrV3GroupMetadataJSON, ZarrV3MetadataJSON } from "./v3.js";
+/** A standard issue that also keeps zarr-metadata's machine-readable kind. */
+export interface StandardIssue extends StandardSchemaV1.Issue {
+    readonly kind: IssueKind;
+}
+export declare const jsonValueSchema: StandardSchemaV1<unknown, JSONValue>;
+export declare const metadataFieldV3Schema: StandardSchemaV1<unknown, ZarrV3MetadataFieldJSON>;
+export declare const arrayMetadataV3Schema: StandardSchemaV1<unknown, ZarrV3ArrayMetadataJSON>;
+export declare const groupMetadataV3Schema: StandardSchemaV1<unknown, ZarrV3GroupMetadataJSON>;
+export declare const consolidatedMetadataV3Schema: StandardSchemaV1<unknown, ZarrV3ConsolidatedMetadataJSON>;
+/** The complete `zarr.json` grammar, dispatching on `node_type`. */
+export declare const metadataV3Schema: StandardSchemaV1<unknown, ZarrV3MetadataJSON>;
+export declare const arrayMetadataV2Schema: StandardSchemaV1<unknown, ZarrV2ArrayMetadataJSON>;
+export declare const groupMetadataV2Schema: StandardSchemaV1<unknown, ZarrV2GroupMetadataJSON>;
+export declare const consolidatedMetadataV2Schema: StandardSchemaV1<unknown, ZarrV2ConsolidatedMetadataJSON>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAe,KAAK,SAAS,EAAsC,MAAM,aAAa,CAAC;AAC9F,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAY7D,OAAO,KAAK,EACV,uBAAuB,EACvB,8BAA8B,EAC9B,uBAAuB,EACxB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACV,uBAAuB,EACvB,8BAA8B,EAC9B,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB,8EAA8E;AAC9E,MAAM,WAAW,aAAc,SAAQ,gBAAgB,CAAC,KAAK;IAC3D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAyBD,eAAO,MAAM,eAAe,EAAE,gBAAgB,CAAC,OAAO,EAAE,SAAS,CAA2B,CAAC;AAE7F,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,CACjD,CAAC;AAErC,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,CACjD,CAAC;AAErC,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,CACjD,CAAC;AAErC,eAAO,MAAM,4BAA4B,EAAE,gBAAgB,CACzD,OAAO,EACP,8BAA8B,CACa,CAAC;AAE9C,oEAAoE;AACpE,eAAO,MAAM,gBAAgB,EAAE,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,CAC5C,CAAC;AAEhC,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,CACjD,CAAC;AAErC,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,CACjD,CAAC;AAErC,eAAO,MAAM,4BAA4B,EAAE,gBAAgB,CACzD,OAAO,EACP,8BAA8B,CACa,CAAC"}

package/dist/schemas.js

@@ -0,0 +1,43 @@
+/**
+ * Standard Schema (https://standardschema.dev) objects for every document
+ * kind, so the validators plug into anything that accepts standard schemas
+ * (tRPC, form libraries, ...).
+ *
+ * Each schema wraps the corresponding `safeParse*` function: validation is
+ * synchronous, success carries the narrowed document, and failure carries
+ * the flattened error tree as standard issues. Every issue additionally
+ * keeps its machine-readable `kind` (an extension the standard permits);
+ * consumers wanting the full `ErrorTree` should use `validate*` directly.
+ */
+import { flattenTree } from "./errors.js";
+import { safeParseArrayMetadataV2, safeParseArrayMetadataV3, safeParseConsolidatedMetadataV2, safeParseConsolidatedMetadataV3, safeParseGroupMetadataV2, safeParseGroupMetadataV3, safeParseJson, safeParseMetadataFieldV3, safeParseMetadataV3, } from "./validation.js";
+function toStandardIssue(issue) {
+    return issue.path.length === 0
+        ? { message: issue.message, kind: issue.kind }
+        : { message: issue.message, path: [...issue.path], kind: issue.kind };
+}
+function schemaOf(safeParse) {
+    return {
+        "~standard": {
+            version: 1,
+            vendor: "zarr-metadata",
+            validate: (value) => {
+                const result = safeParse(value);
+                return result.success
+                    ? { value: result.value }
+                    : { issues: flattenTree(result.errors).map(toStandardIssue) };
+            },
+        },
+    };
+}
+export const jsonValueSchema = schemaOf(safeParseJson);
+export const metadataFieldV3Schema = schemaOf(safeParseMetadataFieldV3);
+export const arrayMetadataV3Schema = schemaOf(safeParseArrayMetadataV3);
+export const groupMetadataV3Schema = schemaOf(safeParseGroupMetadataV3);
+export const consolidatedMetadataV3Schema = schemaOf(safeParseConsolidatedMetadataV3);
+/** The complete `zarr.json` grammar, dispatching on `node_type`. */
+export const metadataV3Schema = schemaOf(safeParseMetadataV3);
+export const arrayMetadataV2Schema = schemaOf(safeParseArrayMetadataV2);
+export const groupMetadataV2Schema = schemaOf(safeParseGroupMetadataV2);
+export const consolidatedMetadataV2Schema = schemaOf(safeParseConsolidatedMetadataV2);
+//# sourceMappingURL=schemas.js.map

package/dist/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,WAAW,EAAsD,MAAM,aAAa,CAAC;AAG9F,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,+BAA+B,EAC/B,+BAA+B,EAC/B,wBAAwB,EACxB,wBAAwB,EACxB,aAAa,EACb,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AAkBzB,SAAS,eAAe,CAAC,KAAkB;IACzC,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;QAC5B,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE;QAC9C,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;AAC1E,CAAC;AAED,SAAS,QAAQ,CACf,SAA6C;IAE7C,OAAO;QACL,WAAW,EAAE;YACX,OAAO,EAAE,CAAC;YACV,MAAM,EAAE,eAAe;YACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;gBAClB,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;gBAChC,OAAO,MAAM,CAAC,OAAO;oBACnB,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE;oBACzB,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAAC;YAClE,CAAC;SACF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,eAAe,GAAyC,QAAQ,CAAC,aAAa,CAAC,CAAC;AAE7F,MAAM,CAAC,MAAM,qBAAqB,GAChC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,qBAAqB,GAChC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,qBAAqB,GAChC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,4BAA4B,GAGrC,QAAQ,CAAC,+BAA+B,CAAC,CAAC;AAE9C,oEAAoE;AACpE,MAAM,CAAC,MAAM,gBAAgB,GAC3B,QAAQ,CAAC,mBAAmB,CAAC,CAAC;AAEhC,MAAM,CAAC,MAAM,qBAAqB,GAChC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,qBAAqB,GAChC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AAErC,MAAM,CAAC,MAAM,4BAA4B,GAGrC,QAAQ,CAAC,+BAA+B,CAAC,CAAC"}

package/dist/standard-schema.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The Standard Schema V1 interface (https://standardschema.dev), vendored.
+ *
+ * Standard Schema is the interoperability contract implemented by Zod,
+ * Valibot, ArkType, and consumed by tRPC, form libraries, and others. The
+ * spec is designed to be copied into implementing libraries so they stay
+ * dependency-free; the test suite checks this copy against the official
+ * `@standard-schema/spec` types (a devDependency) so it cannot drift.
+ */
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,qCAAqC;AACrC,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,gDAAgD;IAChD,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,0CAA0C;QAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpB,6CAA6C;QAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,sCAAsC;QACtC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAChF,iDAAiD;QACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;KACnD;IAED,qDAAqD;IACrD,KAAY,MAAM,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC;IAEnE,mDAAmD;IACnD,UAAiB,aAAa,CAAC,MAAM;QACnC,8BAA8B;QAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,+BAA+B;QAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;KAC7B;IAED,gDAAgD;IAChD,UAAiB,aAAa;QAC5B,uCAAuC;QACvC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;KACvC;IAED,iDAAiD;IACjD,UAAiB,KAAK;QACpB,sCAAsC;QACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,qCAAqC;QACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC;KACtE;IAED,+CAA+C;IAC/C,UAAiB,WAAW;QAC1B,2CAA2C;QAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;KAC3B;IAED,2CAA2C;IAC3C,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,oCAAoC;QACpC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QACtB,qCAAqC;QACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB;IAED,kDAAkD;IAClD,KAAY,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACnE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAC;IAEX,mDAAmD;IACnD,KAAY,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACpE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAC;CACb"}