@effected/schemastore 0.5.0 → 0.6.0

package/KeywordFamilies.js

@@ -57,8 +57,9 @@
 *
 * Both consumers of the registry route through {@link KeywordFamilies.isDeclared}:
 * `DocumentLint`'s `UnknownKeyword` check (a declared key is not flagged) and
-* `AnnotationCarriers` (only declared keys are re-grafted after the Draft-07
-* lowering). One predicate, so the lint and the carriers cannot drift.
+* `StoreDocument.fromSchema`'s gate (a key outside the families fails the
+* build rather than being emitted). One predicate, so the lint and the gate
+* cannot drift.
 */
 const VSCODE_KEYWORDS = /* @__PURE__ */ new Set([
 	"allowTrailingCommas",

package/README.md

@@ -5,7 +5,7 @@
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
 [![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Build, version, validate and lint SchemaStore-shaped Draft-07 JSON Schema documents from Effect Schema sources. Core effect already owns the generation pipeline: `Schema.toJsonSchemaDocument` produces Draft 2020-12 and `JsonSchema.toDocumentDraft07` lowers it. This package owns what [SchemaStore](https://www.schemastore.org) expects around that output — the publication shape (`$schema` + `$id` + root + `$defs`, with the `#/definitions` → `#/$defs` ref rewrite the lowering makes necessary), annotation carriers that keep the language-server keyword families alive through the lowering, catalog entries in both versioning modes, structural and hygiene lints, ajv strict-mode validation, canonical JSON text and content-comparing write-if-changed file IO. `SchemaPipeline` runs that whole emit loop over a list of targets, so a build script calls one function.
+Build, version, validate and lint SchemaStore-shaped Draft-07 JSON Schema documents from Effect Schema sources. Core effect already owns the generation pipeline: `Schema.toJsonSchemaDocument` produces Draft 2020-12 and `JsonSchema.toDocumentDraft07` lowers it. This package owns what [SchemaStore](https://www.schemastore.org) expects around that output — the publication shape (`$schema` + `$id` + root + `$defs`, with the `#/definitions` → `#/$defs` ref rewrite the lowering makes necessary), the gate that holds a document's non-standard surface to the language-server keyword families it declares, catalog entries in both versioning modes, structural and hygiene lints, ajv strict-mode validation, canonical JSON text and content-comparing write-if-changed file IO. `SchemaPipeline` runs that whole emit loop over a list of targets, so a build script calls one function.
 
 > **Pre-release.** This package is part of the `@effected/*` kit, in pre-`1.0.0`
 > development against a single pinned Effect v4 prerelease. Packages graduate to
@@ -21,7 +21,7 @@ Build, version, validate and lint SchemaStore-shaped Draft-07 JSON Schema docume
 
 ## Why @effected/schemastore
 
-Generating a JSON Schema from an Effect Schema is a solved problem — core does it. Publishing that schema where editors find it is not. SchemaStore recommends Draft-07 because that is what the language servers actually support, and core's Draft-07 lowering has two consequences a publisher must deal with: it rewrites `$ref` pointers to the canonical `#/definitions/...` form while the published document keeps its pool under `$defs`, and it drops every keyword outside its fixed copy-list — which is exactly where `markdownDescription`, `x-taplo` and the other editor keywords live. Around the document itself sits SchemaStore's own contract: ajv strict mode as the validation gate, catalog entries whose `fileMatch` patterns must not be generic and versioned schemas as suffixed files plus a `versions` map whose `url` points at the latest. This package is that last mile, so a build script does not have to reinvent it.
+Generating a JSON Schema from an Effect Schema is a solved problem — core does it. Publishing that schema where editors find it is not. SchemaStore recommends Draft-07 because that is what the language servers actually support, and core's Draft-07 lowering has two consequences a publisher must deal with: it rewrites `$ref` pointers to the canonical `#/definitions/...` form while the published document keeps its pool under `$defs`, and it carries unknown and custom keywords through as opaque values — so `markdownDescription`, `x-taplo` and the other editor keywords survive, and the publisher's problem is not getting them through but keeping anything *else* out of a document SchemaStore's own gate would reject. Around the document itself sits SchemaStore's own contract: ajv strict mode as the validation gate, catalog entries whose `fileMatch` patterns must not be generic and versioned schemas as suffixed files plus a `versions` map whose `url` points at the latest. This package is that last mile, so a build script does not have to reinvent it.
 
 The scope is deliberately narrow. There is no schema construction here, no ref resolution beyond the document's own `$defs` pool and no dialect conversion — core's `JsonSchema` owns the generation pipeline, ajv provides the validation gate and this package owns the SchemaStore shape in between.
 
@@ -75,7 +75,7 @@ console.log(Effect.runSync(program));
 // }
 ```
 
-`fromSchema` runs the whole pipeline — 2020-12 generation, Draft-07 lowering, the `$ref` rewrite and the annotation re-graft — so every `$ref` in a built document already resolves against its `$defs` pool. `toJson()` is the flat publication shape (`$defs` omitted when empty) and `serializeResult` routes through the owned canonical serializer, tab-indented with a single trailing newline. If core cannot convert a schema, the failure is typed as `SchemaConversionError` and carries the `$id` and the structured cause.
+`fromSchema` runs the whole pipeline — 2020-12 generation, Draft-07 lowering, the `$ref` rewrite and the declared-family gate — so every `$ref` in a built document already resolves against its `$defs` pool. `toJson()` is the flat publication shape (`$defs` omitted when empty) and `serializeResult` routes through the owned canonical serializer, tab-indented with a single trailing newline. If core cannot convert a schema, the failure is typed as `SchemaConversionError` and carries the `$id` and the structured cause.
 
 ## Annotate at the definition site
 
@@ -83,7 +83,7 @@ One constraint bites consumers who do not know it, so it comes before the featur
 
 ## Carrying language-server annotations
 
-SchemaStore documents lean on non-standard keywords the editors read: the vscode-json-languageservice set (`markdownDescription`, `defaultSnippets`, `enumDescriptions`, `markdownEnumDescriptions`, `allowTrailingCommas`), taplo's `x-taplo` keys, tombi's `x-tombi-*` and IntelliJ's `x-intellij-*`. Effect Schema annotations accept arbitrary string keys, so `Schema.String.annotate({ "x-taplo": { ... } })` type-checks with no module augmentation — but core's Draft-07 lowering copies a fixed keyword subset and would drop them. `StoreDocument.fromSchema` re-grafts the declared families onto the lowered document with a parallel walk (`AnnotationCarriers`), so the annotation you wrote is the keyword that ships:
+SchemaStore documents lean on non-standard keywords the editors read: the vscode-json-languageservice set (`markdownDescription`, `defaultSnippets`, `enumDescriptions`, `markdownEnumDescriptions`, `allowTrailingCommas`), taplo's `x-taplo` keys, tombi's `x-tombi-*` and IntelliJ's `x-intellij-*`. Effect Schema annotations accept arbitrary string keys, so `Schema.String.annotate({ "x-taplo": { ... } })` type-checks with no module augmentation, and core's Draft-07 lowering carries the key through as an opaque value — in place, on the node you attached it to. `StoreDocument.fromSchema` admits the declared families unconditionally, so the annotation you wrote is the keyword that ships:
 
 ```ts
 import { StoreDocument } from "@effected/schemastore";
@@ -104,7 +104,9 @@ console.log(Effect.runSync(program));
 // => { name: { type: "string", "x-taplo": { docs: { main: "The display name." } } } }
 ```
 
-The declared families are always admitted — `KeywordFamilies` is the one registry, consumed by both the carriers and the lint, so the two cannot drift on what counts as declared. A caller-supplied `includeAnnotationKey` predicate is consulted in addition, but know the boundary: keys it admits outside the declared families reach the Draft 2020-12 document and are still dropped by the lowering.
+The declared families are always admitted, whatever a caller-supplied `includeAnnotationKey` answers — `KeywordFamilies` is the one registry, consumed by both the gate and the lint, so the two cannot drift on what counts as declared. The predicate's only remaining effect is to fail the build: a key it admits outside the declared families raises `UndeclaredAnnotationKeyError`, naming every offending key. That is deliberate. This package emits SchemaStore-compatible documents only, and the families are the whole non-standard surface it will ship, so a predicate that reaches past them is a mistake worth hearing about rather than a preference worth honouring quietly.
+
+One thing the package does *not* do to a declared-family value is walk inside it. The `#/definitions` → `#/$defs` `$ref` rewrite skips those payloads entirely: they are opaque advice addressed to a language server, so a `$ref`-shaped string inside one means whatever that tool says it means and survives verbatim.
 
 `KeywordFamilies` splits into two groups. The upstream families above are mirrored from SchemaStore's own CONTRIBUTING guide — vocabularies the language servers already read. The `x-ai-` prefix (with the trailing dash — bare `x-ai` and a look-alike like `x-aida-foo` are not declared) is different: a house machine-annotation namespace this package owns rather than mirrors, meant for a machine reader rather than an editor. It is a namespace, not a fixed vocabulary — any key under the prefix is declared, and the one recommended (non-binding) key is `x-ai-hint`, a string instruction to a machine reader about the annotated value. A key under the prefix must be one ajv can register: after `x-ai-` only `[A-Za-z0-9_$:-]` (ajv holds a keyword name to `/^[a-z_$][a-z0-9_$:-]*$/i`), so a dot, a space, a slash, an `@`, a `+` or a non-ASCII character makes the engine gate reject the whole document as a finding. A declared-family value must itself be JSON, and must not contain an `$id` — or a repeated `$anchor` — at any depth, not merely as its own top-level key: ajv's reference collection walks unknown keywords looking for them, and a colliding one fails the compile. An empty-string `$id` resolves to the root id and collides too. No upstream tool sanctions `x-ai-` today, so it is intended for self-hosted publication rather than submission to schemastore.org without that repo's own validation-config entry. Because `x-ai-*` advises a reader rather than asserting anything, `DocumentDiff` classifies it as an annotation: adopting the family on an already-published versioned document rewrites that file in place, the same as any other prose change.
 
@@ -272,7 +274,7 @@ Both gates' findings normalize into one `PipelineFinding` shape, so a single pre
 SchemaPipeline.run(targets, { blocking: (finding) => finding.source === "validator" });
 ```
 
-Worth knowing which gate actually stops you here. A target carries a `Schema`, so pipeline documents come from `fromSchema`, and the Draft-07 lowering drops undeclared keywords before the lint ever sees them: `UnknownKeyword` is effectively unreachable through this entry point and **the engine gate is what blocks in practice**. The lint's warning checks earn their keep on depth and on documents the pipeline did not build, such as a hand-assembled `StoreDocument.draft07` or one read back off disk.
+Worth knowing which gate actually stops you here. A target carries a `Schema`, so pipeline documents come from `fromSchema`, which never admits an undeclared keyword in the first place: `UnknownKeyword` is effectively unreachable through this entry point and **the engine gate is what blocks in practice**. The lint's warning checks earn their keep on depth and on documents the pipeline did not build, such as a hand-assembled `StoreDocument.draft07` or one read back off disk.
 
 Findings come back as values and are never logged, so the wording of your build output stays yours. A blocking finding fails with `SchemaGateError` carrying every finding that blocked. `run` is **two-phase and all-or-nothing across targets**: every target is generated, gated, and — for a target the contract policy guards — classified against its predecessor before any file is touched, and only then are the held documents written, in order. A gate or contract failure on the third target therefore leaves the first two unwritten too, not merely the third; nothing is written unless every target passes both gates.
 
@@ -316,7 +318,7 @@ The classification is key-order insensitive and keyword-position aware, like the
 ## Features
 
 - `StoreDocument` — the assembly pipeline: `fromSchema` / `fromSchemaResult`, the `draft07` constructor for hand-built documents, the flat `toJson()` publication shape, `serializeResult()`, the `DRAFT_07_META_SCHEMA` constant and `SchemaConversionError`.
-- `AnnotationCarriers` / `KeywordFamilies` — the post-lowering re-graft and the one registry of declared keyword families (upstream language-server families plus the house `x-ai-` machine-annotation namespace), consumed by both the carriers and the lint so they cannot disagree.
+- `KeywordFamilies` — the one registry of declared keyword families (upstream language-server families plus the house `x-ai-` machine-annotation namespace), consumed by both the `fromSchema` gate and the lint so they cannot disagree.
 - `SchemaVersioning` / `SchemaVersion` — full-SemVer version labels with `parseResult` / `parse`, the `Order` instance and `latest`, `isPinned` and `next` for the contract-change version bump, plus `fileName`, `schemaUrl` and `catalogUrls` deriving both catalog modes.
 - `CatalogEntry` — the `catalog.json` entry as a `Schema.Class`, `assemble` and the `fileMatch` hygiene lint (`CatalogLintFinding`).
 - `DocumentLint` — the total structural lint returning `DocumentLintFinding` values, never an error.

package/StoreDocument.js

@@ -1,6 +1,5 @@
-import { KeywordFamilies } from "./KeywordFamilies.js";
-import { AnnotationCarriers } from "./AnnotationCarriers.js";
 import { CanonicalJson } from "./CanonicalJson.js";
+import { KeywordFamilies } from "./KeywordFamilies.js";
 import { Effect, JsonSchema, Result, Schema } from "effect";
 
 //#region src/StoreDocument.ts
@@ -34,21 +33,51 @@ var SchemaConversionError = class extends Schema.TaggedError()("SchemaConversion
 		return `Failed to build SchemaStore document "${this.$id}"`;
 	}
 };
+/**
+* Indicates that a caller-supplied `includeAnnotationKey` admitted an
+* annotation key outside the declared keyword families
+* ({@link KeywordFamilies}).
+*
+* Raised by {@link StoreDocument.fromSchema}. This package emits
+* SchemaStore-compatible documents only, so the declared families are the
+* whole permitted non-standard surface. A key outside them is refused
+* loudly rather than emitted — which would ship a document SchemaStore's
+* own gate rejects — or silently omitted, which would hide the mistake in
+* the caller's predicate.
+*
+* The predicate itself cannot be introspected, so the offending keys are
+* the ones it actually admitted while the document was being generated: a
+* key the source schema never annotates cannot appear here.
+*
+* @public
+*/
+var UndeclaredAnnotationKeyError = class extends Schema.TaggedError()("UndeclaredAnnotationKeyError", {
+	/** The `$id` of the document that was being built. */
+	$id: Schema.String,
+	/** The offending keys, deduplicated and sorted. */
+	keys: Schema.Array(Schema.String)
+}) {
+	get message() {
+		const keys = this.keys.map((key) => `"${key}"`).join(", ");
+		return `Document "${this.$id}" admits annotation keys outside the declared families: ${keys}`;
+	}
+};
 const DEFINITIONS_REF_PREFIX = /^#\/definitions(?=\/|$)/;
 var RewriteDepthExceeded = class {
 	_tag = "RewriteDepthExceeded";
 };
-const carry = (source, target) => {
-	const result = AnnotationCarriers.carryResult(source, target);
-	if (Result.isFailure(result)) throw result.failure;
-	return result.success;
-};
 const restoreDefsRefs = (node, depth) => {
 	if (depth >= 256) throw new RewriteDepthExceeded();
 	if (Array.isArray(node)) return node.map((item) => restoreDefsRefs(item, depth + 1));
 	if (typeof node === "object" && node !== null) {
 		const out = Object.create(null);
-		for (const [key, value] of Object.entries(node)) out[key] = key === "$ref" && typeof value === "string" ? value.replace(DEFINITIONS_REF_PREFIX, "#/$defs") : restoreDefsRefs(value, depth + 1);
+		for (const [key, value] of Object.entries(node)) {
+			if (KeywordFamilies.isDeclared(key)) {
+				out[key] = value;
+				continue;
+			}
+			out[key] = key === "$ref" && typeof value === "string" ? value.replace(DEFINITIONS_REF_PREFIX, "#/$defs") : restoreDefsRefs(value, depth + 1);
+		}
 		return out;
 	}
 	return node;
@@ -63,9 +92,17 @@ const restoreDefsRefs = (node, depth) => {
 * `JsonSchema.toDocumentDraft07` lowering, the `#/definitions` →
 * `#/$defs` `$ref` rewrite the lowering makes necessary — so every `$ref`
 * in a built document already resolves against the `$defs` pool — and the
-* {@link AnnotationCarriers} re-graft, so annotated non-standard keyword
-* families ({@link KeywordFamilies}) survive into the built document. The
-* package owns assembly and publication shape, not a JSON Schema engine.
+* gate that holds the document's non-standard surface to the declared
+* keyword families ({@link KeywordFamilies}). The package owns assembly and
+* publication shape, not a JSON Schema engine.
+*
+* Annotated declared-family keys survive into the built document because
+* core's Draft-07 lowering copies unknown and custom keywords through as
+* opaque values, in place, including across the tuple coordinate move
+* (2020-12 `prefixItems[i]` → Draft-07 `items[i]`, trailing `items` →
+* `additionalItems`). This package therefore does no re-grafting of its
+* own; it only declines to rewrite `$ref`-shaped strings *inside* those
+* opaque payloads.
 *
 * @public
 */
@@ -117,14 +154,23 @@ var StoreDocument = class StoreDocument extends Schema.Class("StoreDocument")({
 	static fromSchemaResult(source, options) {
 		try {
 			const userIncludes = options.jsonSchema?.includeAnnotationKey;
+			const undeclared = /* @__PURE__ */ new Set();
 			const document = Schema.toJsonSchemaDocument(source, {
 				...options.jsonSchema,
-				includeAnnotationKey: (key) => KeywordFamilies.isDeclared(key) || userIncludes?.(key) === true
+				includeAnnotationKey: (key) => {
+					if (KeywordFamilies.isDeclared(key)) return true;
+					if (userIncludes?.(key) === true) undeclared.add(key);
+					return false;
+				}
 			});
+			if (undeclared.size > 0) return Result.fail(UndeclaredAnnotationKeyError.make({
+				$id: options.$id,
+				keys: [...undeclared].sort()
+			}));
 			const lowered = JsonSchema.toDocumentDraft07(document);
-			const root = carry(document.schema, restoreDefsRefs(lowered.schema, 0));
+			const root = restoreDefsRefs(lowered.schema, 0);
 			const defs = Object.create(null);
-			for (const [name, definition] of Object.entries(lowered.definitions)) defs[name] = carry(document.definitions[name], restoreDefsRefs(definition, 1));
+			for (const [name, definition] of Object.entries(lowered.definitions)) defs[name] = restoreDefsRefs(definition, 1);
 			return Result.succeed(StoreDocument.make({
 				$schema: DRAFT_07_META_SCHEMA,
 				$id: options.$id,
@@ -169,4 +215,4 @@ var StoreDocument = class StoreDocument extends Schema.Class("StoreDocument")({
 };
 
 //#endregion
-export { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument };
+export { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument, UndeclaredAnnotationKeyError };

package/index.d.ts

@@ -1,73 +1,4 @@
 import { Context, Effect, FileSystem, Layer, Option, Order, Path, Result, Schema } from "effect";
-//#region src/AnnotationCarriers.d.ts
-declare const CarrierDepthExceededError_base: Schema.Class<CarrierDepthExceededError, Schema.TaggedStruct<"CarrierDepthExceededError", {
-  /** JSON pointer (in the lowered document's coordinates) where the cap was hit. */
-  readonly path: Schema.String;
-  /** The nesting cap that was exceeded. */
-  readonly maxDepth: Schema.Number;
-}>, import("effect/Cause").YieldableError>;
-/**
- * Indicates that the carrier re-graft walk nested past the package's
- * hardening cap (256 levels), which also intercepts cyclic inputs before
- * they can recurse forever.
- *
- * Raised by {@link AnnotationCarriers.carry}.
- *
- * @public
- */
-declare class CarrierDepthExceededError extends CarrierDepthExceededError_base {
-  get message(): string;
-}
-/**
- * Re-grafts the declared non-standard keyword families
- * ({@link KeywordFamilies}) from a Draft 2020-12 schema node onto its
- * lowered Draft-07 counterpart.
- *
- * Why this exists: annotation keys admitted into the Draft 2020-12 document
- * (core's `includeAnnotationKey`) are **dropped by core's Draft-07 lowering**,
- * whose keyword walk copies a fixed subset — verified against the installed
- * beta. Carrying `x-taplo`, `x-tombi-*`, `x-intellij-*` or the vscode set
- * into an emitted SchemaStore document therefore requires this post-lowering
- * step; it cannot ride `ToJsonSchemaOptions` alone.
- *
- * The walk mirrors the lowering's own structural rules, so every carrier
- * lands on the node the annotation was attached to — including the one
- * coordinate move the lowering makes (2020-12 `prefixItems[i]` → Draft-07
- * `items[i]`, trailing `items` → `additionalItems`). Only declared-family
- * keys are copied; nothing else about the target changes.
- *
- * `StoreDocument.fromSchema` applies this automatically to the root schema
- * and every `$defs` pool entry — annotate a schema node
- * (`Schema.String.annotate({ "x-taplo": { hidden: true } })`) and the key
- * appears in the built document. Call this directly only when driving core's
- * pipeline yourself.
- *
- * Know the boundary (core behavior, probed at the installed beta): an
- * annotation must sit on the schema **definition** node. Annotating a
- * hoisted (identifier-carrying) schema at its *usage* site — e.g.
- * `Person.annotate({...})` inside a struct field — reaches neither the
- * `$ref` node nor the pool entry, even in the 2020-12 document, so there is
- * nothing to carry.
- *
- * @public
- */
-declare class AnnotationCarriers {
-  private constructor();
-  /**
-   * Grafts declared-family keys from `source` (a Draft 2020-12 schema
-   * node) onto `target` (its lowered Draft-07 counterpart), returning a
-   * new node. Pure and synchronous — the primitive form;
-   * {@link AnnotationCarriers.carry} is the same walk behind a span.
-   */
-  static carryResult(source: unknown, target: unknown): Result.Result<unknown, CarrierDepthExceededError>;
-  /**
-   * Effect form of {@link AnnotationCarriers.carryResult}, adding only the
-   * `AnnotationCarriers.carry` span. Defined in terms of the `Result`
-   * primitive — synchronous callers can use that variant directly.
-   */
-  static readonly carry: (source: unknown, target: unknown) => Effect.Effect<unknown, CarrierDepthExceededError, never>;
-}
-//#endregion
 //#region src/CanonicalJson.d.ts
 declare const NonJsonValueError_base: Schema.Class<NonJsonValueError, Schema.TaggedStruct<"NonJsonValueError", {
   /** JSON pointer to the offending value (`""` is the document root). */
@@ -87,7 +18,7 @@ declare const NonJsonValueError_base: Schema.Class<NonJsonValueError, Schema.Tag
  *
  * @public
  */
-declare class NonJsonValueError extends NonJsonValueError_base {
+export declare class NonJsonValueError extends NonJsonValueError_base {
   get message(): string;
 }
 declare const JsonDepthExceededError_base: Schema.Class<JsonDepthExceededError, Schema.TaggedStruct<"JsonDepthExceededError", {
@@ -105,7 +36,7 @@ declare const JsonDepthExceededError_base: Schema.Class<JsonDepthExceededError,
  *
  * @public
  */
-declare class JsonDepthExceededError extends JsonDepthExceededError_base {
+export declare class JsonDepthExceededError extends JsonDepthExceededError_base {
   get message(): string;
 }
 /**
@@ -149,7 +80,7 @@ interface CanonicalJsonOptions {
  *
  * @public
  */
-declare class CanonicalJson {
+export declare class CanonicalJson {
   private constructor();
   /**
    * Serializes `value` to canonical JSON text. Pure and synchronous — the
@@ -213,7 +144,7 @@ type SchemaChange = "none" | "annotations" | "contract";
  *
  * @public
  */
-declare class DocumentDiff {
+export declare class DocumentDiff {
   private constructor();
   /**
    * Classify the difference between two emitted document values (the
@@ -253,7 +184,7 @@ declare class DocumentDiff {
  *
  * @public
  */
-declare const DRAFT_07_META_SCHEMA = "http://json-schema.org/draft-07/schema#";
+export declare const DRAFT_07_META_SCHEMA = "http://json-schema.org/draft-07/schema#";
 declare const SchemaConversionError_base: Schema.Class<SchemaConversionError, Schema.TaggedStruct<"SchemaConversionError", {
   /** The `$id` of the document that failed to build. */
   readonly $id: Schema.String;
@@ -270,7 +201,34 @@ declare const SchemaConversionError_base: Schema.Class<SchemaConversionError, Sc
  *
  * @public
  */
-declare class SchemaConversionError extends SchemaConversionError_base {
+export declare class SchemaConversionError extends SchemaConversionError_base {
+  get message(): string;
+}
+declare const UndeclaredAnnotationKeyError_base: Schema.Class<UndeclaredAnnotationKeyError, Schema.TaggedStruct<"UndeclaredAnnotationKeyError", {
+  /** The `$id` of the document that was being built. */
+  readonly $id: Schema.String;
+  /** The offending keys, deduplicated and sorted. */
+  readonly keys: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a caller-supplied `includeAnnotationKey` admitted an
+ * annotation key outside the declared keyword families
+ * ({@link KeywordFamilies}).
+ *
+ * Raised by {@link StoreDocument.fromSchema}. This package emits
+ * SchemaStore-compatible documents only, so the declared families are the
+ * whole permitted non-standard surface. A key outside them is refused
+ * loudly rather than emitted — which would ship a document SchemaStore's
+ * own gate rejects — or silently omitted, which would hide the mistake in
+ * the caller's predicate.
+ *
+ * The predicate itself cannot be introspected, so the offending keys are
+ * the ones it actually admitted while the document was being generated: a
+ * key the source schema never annotates cannot appear here.
+ *
+ * @public
+ */
+export declare class UndeclaredAnnotationKeyError extends UndeclaredAnnotationKeyError_base {
   get message(): string;
 }
 /**
@@ -287,14 +245,17 @@ interface StoreDocumentOptions {
    * `includeAnnotationKey`).
    *
    * The declared non-standard keyword families ({@link KeywordFamilies})
-   * are **always admitted** and carried into the built document — annotate
-   * a schema node (`Schema.String.annotate({ "x-taplo": ... })`) and the
-   * key survives the Draft-07 lowering via the post-lowering re-graft
-   * ({@link AnnotationCarriers}). A supplied `includeAnnotationKey` is
-   * consulted *in addition* for other keys; know the boundary: keys it
-   * admits outside the declared families reach the Draft 2020-12 document
-   * but are **dropped by the Draft-07 lowering** (its keyword walk copies
-   * a fixed subset) — verified against the installed beta.
+   * are **always admitted**, regardless of what a supplied
+   * `includeAnnotationKey` answers — annotate a schema node
+   * (`Schema.String.annotate({ "x-taplo": ... })`) and the key appears in
+   * the built document, in place, on the node it was attached to.
+   *
+   * A supplied `includeAnnotationKey` is consulted only for other keys,
+   * and **admitting one fails the build** with
+   * {@link UndeclaredAnnotationKeyError}. The families are the entire
+   * non-standard surface this package will emit, so the predicate has no
+   * admitting role left; it survives only because the rest of
+   * `ToJsonSchemaOptions` passes through, and is best left unset.
    */
   readonly jsonSchema?: Schema.ToJsonSchemaOptions;
 }
@@ -318,13 +279,21 @@ declare const StoreDocument_base: Schema.Class<StoreDocument, Schema.Struct<{
  * `JsonSchema.toDocumentDraft07` lowering, the `#/definitions` →
  * `#/$defs` `$ref` rewrite the lowering makes necessary — so every `$ref`
  * in a built document already resolves against the `$defs` pool — and the
- * {@link AnnotationCarriers} re-graft, so annotated non-standard keyword
- * families ({@link KeywordFamilies}) survive into the built document. The
- * package owns assembly and publication shape, not a JSON Schema engine.
+ * gate that holds the document's non-standard surface to the declared
+ * keyword families ({@link KeywordFamilies}). The package owns assembly and
+ * publication shape, not a JSON Schema engine.
+ *
+ * Annotated declared-family keys survive into the built document because
+ * core's Draft-07 lowering copies unknown and custom keywords through as
+ * opaque values, in place, including across the tuple coordinate move
+ * (2020-12 `prefixItems[i]` → Draft-07 `items[i]`, trailing `items` →
+ * `additionalItems`). This package therefore does no re-grafting of its
+ * own; it only declines to rewrite `$ref`-shaped strings *inside* those
+ * opaque payloads.
  *
  * @public
  */
-declare class StoreDocument extends StoreDocument_base {
+export declare class StoreDocument extends StoreDocument_base {
   /**
    * Builds a Draft-07 document from its parts, filling `$schema` with
    * {@link DRAFT_07_META_SCHEMA}.
@@ -357,13 +326,13 @@ declare class StoreDocument extends StoreDocument_base {
    * synchronous — the primitive form; {@link StoreDocument.fromSchema} is
    * the same pipeline behind a span.
    */
-  static fromSchemaResult(source: Schema.Constraint, options: StoreDocumentOptions): Result.Result<StoreDocument, SchemaConversionError>;
+  static fromSchemaResult(source: Schema.Constraint, options: StoreDocumentOptions): Result.Result<StoreDocument, SchemaConversionError | UndeclaredAnnotationKeyError>;
   /**
    * Effect form of {@link StoreDocument.fromSchemaResult}, adding only the
    * `StoreDocument.fromSchema` span. Defined in terms of the `Result`
    * primitive — synchronous callers can use that variant directly.
    */
-  static readonly fromSchema: (source: Schema.Constraint, options: StoreDocumentOptions) => Effect.Effect<StoreDocument, SchemaConversionError, never>;
+  static readonly fromSchema: (source: Schema.Constraint, options: StoreDocumentOptions) => Effect.Effect<StoreDocument, SchemaConversionError | UndeclaredAnnotationKeyError, never>;
   /**
    * The flat SchemaStore publication shape: `$schema`, `$id`, the root
    * schema's keywords spread at the top level, then the `$defs` pool.
@@ -392,7 +361,7 @@ declare const SchemaFileReadError_base: Schema.Class<SchemaFileReadError, Schema
  *
  * @public
  */
-declare class SchemaFileReadError extends SchemaFileReadError_base {
+export declare class SchemaFileReadError extends SchemaFileReadError_base {
   get message(): string;
 }
 declare const SchemaFileNotFoundError_base: Schema.Class<SchemaFileNotFoundError, Schema.TaggedStruct<"SchemaFileNotFoundError", {
@@ -405,7 +374,7 @@ declare const SchemaFileNotFoundError_base: Schema.Class<SchemaFileNotFoundError
  *
  * @public
  */
-declare class SchemaFileNotFoundError extends SchemaFileNotFoundError_base {
+export declare class SchemaFileNotFoundError extends SchemaFileNotFoundError_base {
   get message(): string;
 }
 declare const SchemaFileWriteError_base: Schema.Class<SchemaFileWriteError, Schema.TaggedStruct<"SchemaFileWriteError", {
@@ -421,7 +390,7 @@ declare const SchemaFileWriteError_base: Schema.Class<SchemaFileWriteError, Sche
  *
  * @public
  */
-declare class SchemaFileWriteError extends SchemaFileWriteError_base {
+export declare class SchemaFileWriteError extends SchemaFileWriteError_base {
   get message(): string;
 }
 /**
@@ -582,7 +551,7 @@ declare const SchemaFile_base: Context.ServiceClass<SchemaFile, "@effected/schem
  *
  * @public
  */
-declare class SchemaFile extends SchemaFile_base {
+export declare class SchemaFile extends SchemaFile_base {
   /** Build the service implementation from `FileSystem` / `Path` in context; use {@link SchemaFile.layer} to provide it. */
   static readonly make: Effect.Effect<SchemaFileShape, never, FileSystem.FileSystem | Path.Path>;
   /**
@@ -604,7 +573,7 @@ declare const InvalidSchemaVersionError_base: Schema.Class<InvalidSchemaVersionE
  *
  * @public
  */
-declare class InvalidSchemaVersionError extends InvalidSchemaVersionError_base {
+export declare class InvalidSchemaVersionError extends InvalidSchemaVersionError_base {
   get message(): string;
 }
 /**
@@ -622,13 +591,13 @@ declare class InvalidSchemaVersionError extends InvalidSchemaVersionError_base {
  *
  * @public
  */
-declare const SchemaVersion: Schema.brand<Schema.String, "SchemaVersion">;
+export declare const SchemaVersion: Schema.brand<Schema.String, "SchemaVersion">;
 /**
  * The type of a validated SchemaStore version label.
  *
  * @public
  */
-type SchemaVersion = typeof SchemaVersion.Type;
+export type SchemaVersion = typeof SchemaVersion.Type;
 /**
  * The `url`/`versions` half of a catalog entry, as assembled by
  * {@link SchemaVersioning.catalogUrls}.
@@ -656,7 +625,7 @@ interface CatalogUrls {
  *
  * @public
  */
-declare class SchemaVersioning {
+export declare class SchemaVersioning {
   private constructor();
   /**
    * Parses a version label. Pure and synchronous — the primitive form;
@@ -775,7 +744,7 @@ declare const CatalogLintFinding_base: Schema.Class<CatalogLintFinding, Schema.S
  *
  * @public
  */
-declare class CatalogLintFinding extends CatalogLintFinding_base {}
+export declare class CatalogLintFinding extends CatalogLintFinding_base {}
 declare const CatalogEntry_base: Schema.Class<CatalogEntry, Schema.Struct<{
   /** The schema's display name in the catalog. */
   readonly name: Schema.String;
@@ -800,7 +769,7 @@ declare const CatalogEntry_base: Schema.Class<CatalogEntry, Schema.Struct<{
  *
  * @public
  */
-declare class CatalogEntry extends CatalogEntry_base {
+export declare class CatalogEntry extends CatalogEntry_base {
   /**
    * Assembles an entry from a catalog identity plus
    * {@link SchemaVersioning.catalogUrls}' inputs: pass `versions` for the
@@ -846,7 +815,7 @@ declare const DocumentLintFinding_base: Schema.Class<DocumentLintFinding, Schema
  *
  * @public
  */
-declare class DocumentLintFinding extends DocumentLintFinding_base {}
+export declare class DocumentLintFinding extends DocumentLintFinding_base {}
 /**
  * Owned structural checks over an assembled {@link StoreDocument} — the
  * always-available half of the validation story (a real-engine gate like
@@ -866,7 +835,7 @@ declare class DocumentLintFinding extends DocumentLintFinding_base {}
  *
  * @public
  */
-declare class DocumentLint {
+export declare class DocumentLint {
   private constructor();
   /**
    * Runs every check; total — hostile nesting degrades to a
@@ -934,8 +903,9 @@ declare class DocumentLint {
  *
  * Both consumers of the registry route through {@link KeywordFamilies.isDeclared}:
  * `DocumentLint`'s `UnknownKeyword` check (a declared key is not flagged) and
- * `AnnotationCarriers` (only declared keys are re-grafted after the Draft-07
- * lowering). One predicate, so the lint and the carriers cannot drift.
+ * `StoreDocument.fromSchema`'s gate (a key outside the families fails the
+ * build rather than being emitted). One predicate, so the lint and the gate
+ * cannot drift.
  */
 /**
  * The declared non-standard keyword families as one predicate: the
@@ -944,7 +914,7 @@ declare class DocumentLint {
  *
  * @public
  */
-declare class KeywordFamilies {
+export declare class KeywordFamilies {
   private constructor();
   /**
    * Whether `key` belongs to a declared non-standard keyword family.
@@ -967,7 +937,7 @@ declare class KeywordFamilies {
  *
  * @public
  */
-interface SchemaTarget {
+export interface SchemaTarget {
   /** The Effect Schema source the document is generated from. */
   readonly schema: Schema.Constraint;
   /** The canonical `$id` URL the generated document declares. */
@@ -1005,7 +975,7 @@ interface SchemaTarget {
  *
  * @public
  */
-declare class SchemaTarget {
+export declare class SchemaTarget {
   private constructor();
   /**
    * Builds an unversioned target. `name` is optional — only catalog
@@ -1048,7 +1018,7 @@ declare const SchemaValidatorError_base: Schema.Class<SchemaValidatorError, Sche
  *
  * @public
  */
-declare class SchemaValidatorError extends SchemaValidatorError_base {
+export declare class SchemaValidatorError extends SchemaValidatorError_base {
   get message(): string;
 }
 declare const ValidationFinding_base: Schema.Class<ValidationFinding, Schema.Struct<{
@@ -1066,7 +1036,7 @@ declare const ValidationFinding_base: Schema.Class<ValidationFinding, Schema.Str
  *
  * @public
  */
-declare class ValidationFinding extends ValidationFinding_base {}
+export declare class ValidationFinding extends ValidationFinding_base {}
 /**
  * Options for {@link SchemaValidatorShape.validate}.
  *
@@ -1132,7 +1102,7 @@ declare const SchemaValidator_base: Context.ServiceClass<SchemaValidator, "@effe
  *
  * @public
  */
-declare class SchemaValidator extends SchemaValidator_base {
+export declare class SchemaValidator extends SchemaValidator_base {
   /**
    * The shipped ajv implementation — the default a consumer provides.
    *
@@ -1191,7 +1161,7 @@ declare const PipelineFinding_base: Schema.Class<PipelineFinding, Schema.Struct<
  *
  * @public
  */
-declare class PipelineFinding extends PipelineFinding_base {
+export declare class PipelineFinding extends PipelineFinding_base {
   /**
    * What to call this finding when rendering it: the check name when the
    * gate named one, the gate itself otherwise.
@@ -1215,7 +1185,7 @@ declare const SchemaGateError_base: Schema.Class<SchemaGateError, Schema.TaggedS
  *
  * @public
  */
-declare class SchemaGateError extends SchemaGateError_base {
+export declare class SchemaGateError extends SchemaGateError_base {
   get message(): string;
 }
 /**
@@ -1260,7 +1230,7 @@ declare const ContractChangeTarget_base: Schema.Class<ContractChangeTarget, Sche
  *
  * @public
  */
-declare class ContractChangeTarget extends ContractChangeTarget_base {}
+export declare class ContractChangeTarget extends ContractChangeTarget_base {}
 declare const SchemaContractChangeError_base: Schema.Class<SchemaContractChangeError, Schema.TaggedStruct<"SchemaContractChangeError", {
   /** Every published target whose contract would change, in target order. */
   readonly targets: Schema.$Array<typeof ContractChangeTarget>;
@@ -1272,7 +1242,7 @@ declare const SchemaContractChangeError_base: Schema.Class<SchemaContractChangeE
  *
  * @public
  */
-declare class SchemaContractChangeError extends SchemaContractChangeError_base {
+export declare class SchemaContractChangeError extends SchemaContractChangeError_base {
   get message(): string;
 }
 /**
@@ -1350,11 +1320,12 @@ interface SchemaPipelineOptions {
    *
    * **Which findings can actually reach you here.** A `SchemaTarget`
    * carries a `Schema`, so the pipeline's documents come from
-   * `StoreDocument.fromSchema` — and the Draft-07 lowering drops every
-   * keyword outside its copy-list, so an undeclared keyword never
-   * survives to be linted. Through this entry point `UnknownKeyword` is
-   * therefore effectively unreachable, and **the engine gate is what
-   * blocks in practice**. The lint's warning checks earn their keep on
+   * `StoreDocument.fromSchema` — which never admits an undeclared
+   * keyword: the pipeline supplies no `includeAnnotationKey`, and one
+   * that admitted anything outside the declared families would fail the
+   * build. An undeclared keyword therefore never exists to be linted.
+   * Through this entry point `UnknownKeyword` is effectively unreachable,
+   * and **the engine gate is what blocks in practice**. The lint's warning checks earn their keep on
    * documents this pipeline did not build — a hand-assembled
    * `StoreDocument.draft07`, or one read back off disk — and on depth,
    * which a schema can genuinely exceed.
@@ -1406,7 +1377,7 @@ interface SchemaPipelineOptions {
  *
  * @public
  */
-declare class SchemaPipeline {
+export declare class SchemaPipeline {
   private constructor();
   /**
    * Run every target: build its document, gather both gates' findings,
@@ -1448,7 +1419,7 @@ declare class SchemaPipeline {
    * );
    * ```
    */
-  static run(targets: ReadonlyArray<SchemaTarget>, options?: SchemaPipelineOptions): Effect.Effect<ReadonlyArray<PipelineResult>, SchemaGateError | SchemaContractChangeError | SchemaConversionError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError | SchemaFileWriteError, SchemaFile | SchemaValidator>;
+  static run(targets: ReadonlyArray<SchemaTarget>, options?: SchemaPipelineOptions): Effect.Effect<ReadonlyArray<PipelineResult>, SchemaGateError | SchemaContractChangeError | SchemaConversionError | UndeclaredAnnotationKeyError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError | SchemaFileWriteError, SchemaFile | SchemaValidator>;
   /**
    * The same walk with **no writes** — the drift-check counterpart, for a
    * CI job asserting the committed schemas are current.
@@ -1463,19 +1434,19 @@ declare class SchemaPipeline {
    * The error channel is left to the mechanisms that genuinely cannot
    * produce a report (generation, serialization, the engine, the read).
    */
-  static check(targets: ReadonlyArray<SchemaTarget>, options?: SchemaPipelineOptions): Effect.Effect<ReadonlyArray<PipelineCheckResult>, SchemaConversionError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError, SchemaFile | SchemaValidator>;
+  static check(targets: ReadonlyArray<SchemaTarget>, options?: SchemaPipelineOptions): Effect.Effect<ReadonlyArray<PipelineCheckResult>, SchemaConversionError | UndeclaredAnnotationKeyError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError, SchemaFile | SchemaValidator>;
   /**
    * {@link SchemaPipeline.run} for a single target, answering its one
    * result directly — so a caller with one target does not index into an
    * array and prove to the type system that element zero exists.
    */
-  static runOne(target: SchemaTarget, options?: SchemaPipelineOptions): Effect.Effect<PipelineResult, SchemaGateError | SchemaContractChangeError | SchemaConversionError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError | SchemaFileWriteError, SchemaFile | SchemaValidator>;
+  static runOne(target: SchemaTarget, options?: SchemaPipelineOptions): Effect.Effect<PipelineResult, SchemaGateError | SchemaContractChangeError | SchemaConversionError | UndeclaredAnnotationKeyError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError | SchemaFileWriteError, SchemaFile | SchemaValidator>;
   /**
    * {@link SchemaPipeline.check} for a single target, answering its one
    * result directly.
    */
-  static checkOne(target: SchemaTarget, options?: SchemaPipelineOptions): Effect.Effect<PipelineCheckResult, SchemaConversionError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError, SchemaFile | SchemaValidator>;
+  static checkOne(target: SchemaTarget, options?: SchemaPipelineOptions): Effect.Effect<PipelineCheckResult, SchemaConversionError | UndeclaredAnnotationKeyError | SchemaValidatorError | CanonicalJsonError | SchemaFileReadError, SchemaFile | SchemaValidator>;
 }
 //#endregion
-export { AnnotationCarriers, CanonicalJson, type CanonicalJsonError, type CanonicalJsonOptions, CarrierDepthExceededError, CatalogEntry, CatalogLintFinding, type CatalogUrls, type CheckResult, type ContractChangePolicy, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, type PipelineCheckResult, PipelineFinding, type PipelineResult, type SchemaChange, SchemaContractChangeError, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, type SchemaFileShape, SchemaFileWriteError, SchemaGateError, SchemaPipeline, type SchemaPipelineOptions, SchemaTarget, SchemaValidator, SchemaValidatorError, type SchemaValidatorOptions, type SchemaValidatorShape, SchemaVersion, SchemaVersioning, type SchemaWriteOptions, StoreDocument, type StoreDocumentOptions, ValidationFinding, type WriteChange, type WriteOutcome, type WriteResult };
+export type { CanonicalJsonError, CanonicalJsonOptions, CatalogUrls, CheckResult, ContractChangePolicy, PipelineCheckResult, PipelineResult, SchemaChange, SchemaFileShape, SchemaPipelineOptions, SchemaValidatorOptions, SchemaValidatorShape, SchemaWriteOptions, StoreDocumentOptions, WriteChange, WriteOutcome, WriteResult };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,14 +1,13 @@
-import { KeywordFamilies } from "./KeywordFamilies.js";
-import { AnnotationCarriers, CarrierDepthExceededError } from "./AnnotationCarriers.js";
 import { CanonicalJson, JsonDepthExceededError, NonJsonValueError } from "./CanonicalJson.js";
 import { InvalidSchemaVersionError, SchemaVersion, SchemaVersioning } from "./SchemaVersioning.js";
 import { CatalogEntry, CatalogLintFinding } from "./CatalogEntry.js";
+import { KeywordFamilies } from "./KeywordFamilies.js";
 import { DocumentDiff } from "./DocumentDiff.js";
 import { DocumentLint, DocumentLintFinding } from "./DocumentLint.js";
 import { SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError } from "./SchemaFile.js";
 import { SchemaValidator, SchemaValidatorError, ValidationFinding } from "./SchemaValidator.js";
-import { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument } from "./StoreDocument.js";
+import { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument, UndeclaredAnnotationKeyError } from "./StoreDocument.js";
 import { ContractChangeTarget, PipelineFinding, SchemaContractChangeError, SchemaGateError, SchemaPipeline } from "./SchemaPipeline.js";
 import { SchemaTarget } from "./SchemaTarget.js";
 
-export { AnnotationCarriers, CanonicalJson, CarrierDepthExceededError, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, PipelineFinding, SchemaContractChangeError, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError, SchemaGateError, SchemaPipeline, SchemaTarget, SchemaValidator, SchemaValidatorError, SchemaVersion, SchemaVersioning, StoreDocument, ValidationFinding };
+export { CanonicalJson, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, PipelineFinding, SchemaContractChangeError, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError, SchemaGateError, SchemaPipeline, SchemaTarget, SchemaValidator, SchemaValidatorError, SchemaVersion, SchemaVersioning, StoreDocument, UndeclaredAnnotationKeyError, ValidationFinding };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/schemastore",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"private": false,
 	"description": "Build, validate, version and publish SchemaStore-shaped Draft-07 JSON Schema documents from Effect Schema sources: document assembly, ajv strict-mode validation, structural lints, catalog entries, canonical JSON and a content-comparing emit pipeline.",
 	"keywords": [
@@ -38,11 +38,11 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/semver": "^0.5.1",
+		"@effected/semver": "^0.6.0",
 		"ajv": "^8.20.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.109"
+		"effect": "4.0.0-rc.112"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/AnnotationCarriers.js

@@ -1,137 +0,0 @@
-import { KeywordFamilies } from "./KeywordFamilies.js";
-import { Effect, Result, Schema } from "effect";
-
-//#region src/AnnotationCarriers.ts
-/**
-* Indicates that the carrier re-graft walk nested past the package's
-* hardening cap (256 levels), which also intercepts cyclic inputs before
-* they can recurse forever.
-*
-* Raised by {@link AnnotationCarriers.carry}.
-*
-* @public
-*/
-var CarrierDepthExceededError = class extends Schema.TaggedError()("CarrierDepthExceededError", {
-	/** JSON pointer (in the lowered document's coordinates) where the cap was hit. */
-	path: Schema.String,
-	/** The nesting cap that was exceeded. */
-	maxDepth: Schema.Number
-}) {
-	get message() {
-		return `Carrier re-graft nesting exceeds ${this.maxDepth} levels at "${this.path}"`;
-	}
-};
-var CarryFailure = class {
-	error;
-	constructor(error) {
-		this.error = error;
-	}
-};
-const escapePointerSegment = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
-const isSchemaObject = (node) => typeof node === "object" && node !== null && !Array.isArray(node);
-const graftMap = (source, target, path, depth) => {
-	if (!isSchemaObject(source) || !isSchemaObject(target)) return target;
-	const out = { ...target };
-	for (const [name, subschema] of Object.entries(source)) if (Object.hasOwn(target, name)) out[name] = graft(subschema, target[name], `${path}/${escapePointerSegment(name)}`, depth + 1);
-	return out;
-};
-const graftArray = (source, target, path, depth) => {
-	if (!Array.isArray(source) || !Array.isArray(target)) return target;
-	return target.map((element, index) => index < source.length ? graft(source[index], element, `${path}/${index}`, depth + 1) : element);
-};
-const graft = (source, target, path, depth) => {
-	if (depth >= 256) throw new CarryFailure(CarrierDepthExceededError.make({
-		path,
-		maxDepth: 256
-	}));
-	if (!isSchemaObject(source) || !isSchemaObject(target)) return target;
-	const out = { ...target };
-	for (const [key, value] of Object.entries(source)) {
-		if (KeywordFamilies.isDeclared(key)) {
-			out[key] = value;
-			continue;
-		}
-		const keyPath = `${path}/${escapePointerSegment(key)}`;
-		switch (key) {
-			case "properties":
-			case "patternProperties":
-				if (Object.hasOwn(out, key)) out[key] = graftMap(value, out[key], keyPath, depth);
-				break;
-			case "additionalProperties":
-			case "propertyNames":
-				if (Object.hasOwn(out, key)) out[key] = graft(value, out[key], keyPath, depth + 1);
-				break;
-			case "allOf":
-			case "anyOf":
-			case "oneOf":
-				if (Object.hasOwn(out, key)) out[key] = graftArray(value, out[key], keyPath, depth);
-				break;
-			case "prefixItems":
-				if (Object.hasOwn(out, "items")) out.items = Array.isArray(value) ? graftArray(value, out.items, `${path}/items`, depth) : graft(value, out.items, `${path}/items`, depth + 1);
-				break;
-			case "items": if (Object.hasOwn(source, "prefixItems")) {
-				if (Object.hasOwn(out, "additionalItems")) out.additionalItems = graft(value, out.additionalItems, `${path}/additionalItems`, depth + 1);
-			} else if (Object.hasOwn(out, "items")) out.items = graft(value, out.items, keyPath, depth + 1);
-		}
-	}
-	return out;
-};
-/**
-* Re-grafts the declared non-standard keyword families
-* ({@link KeywordFamilies}) from a Draft 2020-12 schema node onto its
-* lowered Draft-07 counterpart.
-*
-* Why this exists: annotation keys admitted into the Draft 2020-12 document
-* (core's `includeAnnotationKey`) are **dropped by core's Draft-07 lowering**,
-* whose keyword walk copies a fixed subset — verified against the installed
-* beta. Carrying `x-taplo`, `x-tombi-*`, `x-intellij-*` or the vscode set
-* into an emitted SchemaStore document therefore requires this post-lowering
-* step; it cannot ride `ToJsonSchemaOptions` alone.
-*
-* The walk mirrors the lowering's own structural rules, so every carrier
-* lands on the node the annotation was attached to — including the one
-* coordinate move the lowering makes (2020-12 `prefixItems[i]` → Draft-07
-* `items[i]`, trailing `items` → `additionalItems`). Only declared-family
-* keys are copied; nothing else about the target changes.
-*
-* `StoreDocument.fromSchema` applies this automatically to the root schema
-* and every `$defs` pool entry — annotate a schema node
-* (`Schema.String.annotate({ "x-taplo": { hidden: true } })`) and the key
-* appears in the built document. Call this directly only when driving core's
-* pipeline yourself.
-*
-* Know the boundary (core behavior, probed at the installed beta): an
-* annotation must sit on the schema **definition** node. Annotating a
-* hoisted (identifier-carrying) schema at its *usage* site — e.g.
-* `Person.annotate({...})` inside a struct field — reaches neither the
-* `$ref` node nor the pool entry, even in the 2020-12 document, so there is
-* nothing to carry.
-*
-* @public
-*/
-var AnnotationCarriers = class AnnotationCarriers {
-	constructor() {}
-	/**
-	* Grafts declared-family keys from `source` (a Draft 2020-12 schema
-	* node) onto `target` (its lowered Draft-07 counterpart), returning a
-	* new node. Pure and synchronous — the primitive form;
-	* {@link AnnotationCarriers.carry} is the same walk behind a span.
-	*/
-	static carryResult(source, target) {
-		try {
-			return Result.succeed(graft(source, target, "", 0));
-		} catch (cause) {
-			if (cause instanceof CarryFailure) return Result.fail(cause.error);
-			throw cause;
-		}
-	}
-	/**
-	* Effect form of {@link AnnotationCarriers.carryResult}, adding only the
-	* `AnnotationCarriers.carry` span. Defined in terms of the `Result`
-	* primitive — synchronous callers can use that variant directly.
-	*/
-	static carry = Effect.fn("AnnotationCarriers.carry")((source, target) => Effect.fromResult(AnnotationCarriers.carryResult(source, target)));
-};
-
-//#endregion
-export { AnnotationCarriers, CarrierDepthExceededError };