@effected/schemastore 0.9.1 → 0.11.0

package/index.d.ts

@@ -94,6 +94,22 @@ export declare class CanonicalJson {
    * primitive — synchronous callers can use that variant directly.
    */
   static readonly serialize: (value: unknown, options?: CanonicalJsonOptions | undefined) => Effect.Effect<string, CanonicalJsonError, never>;
+  /**
+   * Content equality under the serializer's own semantics: two values are
+   * equal when they would parse to the same JSON document — object key
+   * order is a serialization detail and is ignored, array order is data
+   * and is not. `NaN` is never equal to itself (it is not JSON). The same
+   * reference compares `true` before any structural walk — so a cyclic
+   * value equals itself — and the comparison is total: two distinct
+   * cyclic or hostile-depth values report `false` at the stack guard
+   * rather than overflowing.
+   *
+   * This is the comparison `SchemaFile`'s write-if-changed and
+   * `DocumentDiff`'s leaf comparison already make, exported so a consumer
+   * writing its own JSON artifact (a catalog entry) can decide "unchanged"
+   * by the same rule instead of re-implementing it.
+   */
+  static equals(left: unknown, right: unknown): boolean;
 }
 //#endregion
 //#region src/DocumentDiff.d.ts
@@ -213,7 +229,10 @@ declare const UndeclaredAnnotationKeyError_base: Schema.Class<UndeclaredAnnotati
 /**
  * Indicates that a caller-supplied `includeAnnotationKey` admitted an
  * annotation key outside the declared keyword families
- * ({@link KeywordFamilies}).
+ * ({@link KeywordFamilies}), or that a
+ * {@link StoreDocumentOptions.rootAnnotations} override names a key outside
+ * the admitted set (the standard annotation keywords plus the declared
+ * families).
  *
  * Raised by {@link StoreDocument.fromSchema}. This package emits
  * SchemaStore-compatible documents only, so the declared families are the
@@ -224,7 +243,8 @@ declare const UndeclaredAnnotationKeyError_base: Schema.Class<UndeclaredAnnotati
  *
  * 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.
+ * key the source schema never annotates cannot appear here. Override keys,
+ * by contrast, are checked up front, before anything is generated.
  *
  * @public
  */
@@ -258,6 +278,39 @@ interface StoreDocumentOptions {
    * `ToJsonSchemaOptions` passes through, and is best left unset.
    */
   readonly jsonSchema?: Schema.ToJsonSchemaOptions;
+  /**
+   * Annotations merged onto the emitted document's root after assembly —
+   * the escape hatch for a generator-side annotation loss the source
+   * schema cannot express (a filtered field, or a root whose annotations
+   * core does not carry).
+   *
+   * Admitted keys are the standard JSON Schema annotation keywords
+   * (`title`, `description`, `$comment`, `default`, `examples`,
+   * `readOnly`, `writeOnly`, `contentMediaType`, `contentEncoding`) and
+   * the declared keyword families
+   * ({@link KeywordFamilies}); any other key fails the build with
+   * {@link UndeclaredAnnotationKeyError}, so the override cannot become a
+   * back door for assertion keywords. Override keys win over generated
+   * ones. The override is checked before generation, so when both this
+   * gate and the `includeAnnotationKey` gate would fire, the override's
+   * keys are the ones reported and the predicate's are not.
+   *
+   * Placement follows the assembled root's shape, in three cases:
+   *
+   * - An inline root (a `Struct`, a primitive) takes the annotations
+   *   directly.
+   * - A bare local `$ref` root (the shape a `Schema.Class` root produces —
+   *   `{ "$ref": "#/$defs/FooEncoded" }`) whose `$defs` entry has no
+   *   other referent takes them on that entry instead: Draft-07
+   *   validators ignore `$ref` siblings, so the root would carry them
+   *   nowhere.
+   * - A bare local `$ref` root whose entry is shared — a recursive class,
+   *   or one another definition also references — is replaced by
+   *   `{ ...annotations, allOf: [{ "$ref": ... }] }`, so the document is
+   *   annotated without every other occurrence of the type inheriting
+   *   the root's title.
+   */
+  readonly rootAnnotations?: Readonly<Record<string, unknown>>;
 }
 declare const StoreDocument_base: Schema.Class<StoreDocument, Schema.Struct<{
   /** The meta-schema URL ({@link DRAFT_07_META_SCHEMA}). */
@@ -597,6 +650,15 @@ export declare const SchemaVersion: Schema.brand<Schema.String, "SchemaVersion">
  * @public
  */
 export type SchemaVersion = typeof SchemaVersion.Type;
+/**
+ * Where a versioned document sits relative to its base: `flat` is
+ * `<name>-<version>.json` (the only shape SchemaStore serves), `versioned`
+ * nests it as `<version>/<name>-<version>.json`. An unversioned document is
+ * `<name>.json` under either.
+ *
+ * @public
+ */
+type SchemaLayout = "flat" | "versioned";
 /**
  * The `url`/`versions` half of a catalog entry, as assembled by
  * {@link SchemaVersioning.catalogUrls}.
@@ -703,42 +765,58 @@ export declare class SchemaVersioning {
    * the label and the ceiling rather than `SemVer.make`'s bare schema failure.
    */
   static next(current: SchemaVersion, change: WriteChange): SchemaVersion;
+  /**
+   * Whether a name is a simple file base name — non-empty, no path
+   * separators, no whitespace — the rule every schema name is held to
+   * ({@link SchemaVersioning.fileName} throws on anything else; `defineConfig`
+   * rejects a schema key the same way). One predicate so the two cannot drift.
+   */
+  static isSimpleName(name: string): boolean;
   /**
    * Derives the schema file name for a catalog name: `name.json`
-   * unversioned, `name-<version>.json` versioned.
+   * unversioned, `name-<version>.json` versioned under the `"flat"`
+   * layout (the default and the only shape SchemaStore serves), or
+   * `<version>/name-<version>.json` under `"versioned"`.
    *
    * The name must be a simple file base name (no separators, no
    * whitespace); anything else is a wiring mistake and throws.
    */
-  static fileName(name: string, version?: SchemaVersion): string;
+  static fileName(name: string, version?: SchemaVersion, layout?: SchemaLayout): string;
   /**
    * The canonical URL a schema file is hosted at: `baseUrl` joined with
    * {@link SchemaVersioning.fileName}.
    */
-  static schemaUrl(baseUrl: string, name: string, version?: SchemaVersion): string;
+  static schemaUrl(baseUrl: string, name: string, version?: SchemaVersion, layout?: SchemaLayout): string;
   /**
    * Assembles the `url`/`versions` half of a catalog entry.
    *
    * Omitting `versions` selects the unversioned mode (`url` only,
    * pointing at the plain `name.json`). Providing them selects the
    * versioned mode: the `versions` map carries every label, and `url`
-   * points at the latest version's file. An **empty** `versions` array is
+   * points at `current` (default: the newest label under
+   * {@link SchemaVersioning.Order}). An **empty** `versions` array is
    * a contradiction (versioned mode with no versions) and throws — pass
-   * `undefined` for the unversioned mode.
+   * `undefined` for the unversioned mode. `current`, when given, must
+   * compare equal under {@link SchemaVersioning.Order} to a member of
+   * `versions` or this throws; `url` is built from that member's own
+   * spelling (the `versions` map's key), not from the `current` argument
+   * verbatim — so a differently-spelled equivalent (`"1.2"` matching a
+   * `"1.2.0"` member) still points `url` at the same file the map does.
+   *
+   * `layout` (default `"flat"`) is forwarded to every URL derivation, so
+   * `"versioned"` nests every map value and `url` under its own version
+   * directory.
    *
-   * Labels are inserted in ascending {@link SchemaVersioning.Order}, but a
-   * bare-major label (`"2"`) is array-index-like, so JavaScript enumerates
-   * it FIRST regardless of insertion order — the serialized order of the
-   * `versions` map is not meaningful when such a label is present. A two-
-   * or three-component label is never integer-like and keeps insertion
-   * order through serialization. Deriving ordering from the labels
-   * themselves (as {@link SchemaVersioning.latest} does) is still the
-   * robust read.
+   * Labels are inserted in ascending {@link SchemaVersioning.Order}; see
+   * {@link CatalogUrls.versions} for why a bare-major key's serialized
+   * position is not meaningful.
    */
   static catalogUrls(options: {
     readonly baseUrl: string;
     readonly name: string;
     readonly versions?: ReadonlyArray<SchemaVersion>;
+    readonly layout?: SchemaLayout;
+    readonly current?: SchemaVersion;
   }): CatalogUrls;
 }
 //#endregion
@@ -788,7 +866,9 @@ export declare class CatalogEntry extends CatalogEntry_base {
    * Assembles an entry from a catalog identity plus
    * {@link SchemaVersioning.catalogUrls}' inputs: pass `versions` for the
    * versioned mode (the `versions` map and latest-pointing `url` are
-   * derived), omit it for the unversioned mode. Throws an `Error` naming
+   * derived), omit it for the unversioned mode. `layout` (default
+   * `"flat"`) and `current` (default: the newest label) are forwarded to
+   * {@link SchemaVersioning.catalogUrls} verbatim. Throws an `Error` naming
    * both spellings when two labels compare equal under
    * {@link SchemaVersioning.Order} (`1.2` and `1.2.0`): each would be its
    * own key and URL for one document.
@@ -800,6 +880,8 @@ export declare class CatalogEntry extends CatalogEntry_base {
     readonly baseUrl: string;
     readonly fileBaseName?: string;
     readonly versions?: ReadonlyArray<SchemaVersion>;
+    readonly layout?: SchemaLayout;
+    readonly current?: SchemaVersion;
   }): CatalogEntry;
   /**
    * The fileMatch hygiene lint over this entry's patterns — pure shape
@@ -845,10 +927,18 @@ export declare class DocumentLintFinding extends DocumentLintFinding_base {}
  *   non-standard families ({@link KeywordFamilies}: `x-taplo*`, `x-tombi-*`,
  *   `x-intellij-*`, `x-ai-*` and the vscode set), which ajv strict mode would reject.
  * - `DescriptionWithoutUrl` — advisory: SchemaStore's description
- *   convention ends the root description with a docs URL line.
- *
- * Tractable because the input is bounded `toJsonSchemaDocument` output;
- * this is not a general JSON Schema validator.
+ *   convention ends the root description with a docs URL line. Read from
+ *   the root, or from the `$defs` entry a bare local `$ref` root names —
+ *   where assembly places a root annotation.
+ *
+ * Tractable because the input is the bounded {@link StoreDocument} shape,
+ * not because assembly built it: the warning checks earn their keep on a
+ * document the pipeline did not build — hand-assembled through
+ * `StoreDocument.draft07`, or read back off disk. A local `$defs` pointer
+ * is decoded the way ajv decodes it, so no `$ref` into the pool that the
+ * engine gate resolves is reported `UnresolvedRef`; a `#/definitions/...`
+ * pointer stays a warning on purpose, since the pool lives under `$defs`.
+ * This is not a general JSON Schema validator.
  *
  * @public
  */
@@ -1068,6 +1158,12 @@ export interface SchemaTarget {
    * `includeAnnotationKey` gate this option is also subject to.
    */
   readonly jsonSchema?: Schema.ToJsonSchemaOptions;
+  /**
+   * Forwarded to {@link StoreDocumentOptions.rootAnnotations}; a
+   * target-level field for the same self-describing reason as
+   * `jsonSchema`.
+   */
+  readonly rootAnnotations?: Readonly<Record<string, unknown>>;
 }
 /**
  * Constructors for `SchemaTarget` values.
@@ -1087,6 +1183,7 @@ export declare class SchemaTarget {
     readonly path: string;
     readonly published?: boolean;
     readonly jsonSchema?: Schema.ToJsonSchemaOptions;
+    readonly rootAnnotations?: Readonly<Record<string, unknown>>;
   }): SchemaTarget;
   /**
    * Builds a versioned target. `name` is **required** here: versioned
@@ -1103,6 +1200,7 @@ export declare class SchemaTarget {
     readonly version: SchemaVersion | string;
     readonly published?: boolean;
     readonly jsonSchema?: Schema.ToJsonSchemaOptions;
+    readonly rootAnnotations?: Readonly<Record<string, unknown>>;
   }): SchemaTarget;
 }
 //#endregion
@@ -1566,42 +1664,144 @@ export declare class SchemaPipeline {
 //#endregion
 //#region src/SchemastoreConfig.d.ts
 declare const ConfigBrand: unique symbol;
+/** The host SchemaStore-hosted documents declare in `$id`. @public */
+export declare const SCHEMASTORE_ID_BASE = "https://json.schemastore.org";
+/** The host SchemaStore's `catalog.json` points `url` at. @public */
+export declare const SCHEMASTORE_CATALOG_BASE = "https://www.schemastore.org";
 /**
- * One catalog entry a `schemastore.config.ts` declares: the SchemaStore
- * `catalog.json` fields plus where to write the assembled entry. The entry's
- * `versions` and `url` are derived by {@link defineConfig} from every
- * versioned schema of the same `name`.
+ * The SchemaStore `catalog.json` fields a schema entry declares, minus
+ * `url`/`versions` — those are derived from the entry's `baseUrl`, `layout`
+ * and `versions`/`current` by {@link defineConfig}, so they cannot disagree
+ * with the schema's own identity.
  *
  * @public
  */
-interface CatalogConfig {
-  readonly name: string;
+interface CatalogInput {
+  /** The catalog description. */
   readonly description: string;
+  /** Glob patterns editors match files against; must be non-empty. */
   readonly fileMatch: ReadonlyArray<string>;
-  readonly baseUrl: string;
-  /** Where to write the assembled entry; relative paths are resolved by the loader against the config file's directory. */
-  readonly path: string;
 }
 /**
- * What a `schemastore.config.ts` hands to {@link defineConfig}: the schema
- * targets, an optional catalog block and an optional partial drift block.
+ * One schema a `schemastore.config.ts` declares, keyed by its own file base
+ * name in {@link SchemastoreConfigInput.schemas}. `$id`, the write `path` and
+ * every catalog URL are derived from `outputDir`, `baseUrl` (this entry's, or
+ * the config's default) and `layout` — never spelled out by hand.
+ *
+ * @public
+ */
+interface SchemaEntryInput {
+  /** The Effect Schema source the document is generated from. */
+  readonly schema: Schema.Constraint;
+  /**
+   * Every version label this schema advertises. Omit for an unversioned
+   * schema (`<name>.json`). An empty array is rejected — omit the field
+   * instead. Two labels that compare equal under
+   * {@link SchemaVersioning.Order} (`"1.2"` and `"1.2.0"`) are rejected as
+   * one version spelled twice.
+   */
+  readonly versions?: ReadonlyArray<string>;
+  /**
+   * Which of `versions` is the one generated at this entry's `path`/`$id`;
+   * the rest become {@link ResolvedSchema.frozen} files the CLI verifies
+   * but does not regenerate. Defaults to the newest label under
+   * {@link SchemaVersioning.Order}. Requires `versions`, and must name one
+   * of them.
+   */
+  readonly current?: string;
+  /**
+   * Whether a consumer already depends on this document at this label —
+   * forwarded to {@link (SchemaTarget:class).(make:1)}. Defaults to `false`.
+   */
+  readonly published?: boolean;
+  /**
+   * Where this schema is hosted: the literal `"schemastore"` (the only
+   * value that expands `$id` to {@link SCHEMASTORE_ID_BASE} and the catalog
+   * URL to {@link SCHEMASTORE_CATALOG_BASE}, and forces the `"flat"`
+   * layout) or an `https://` URL used as ONE base for both `$id` and the
+   * catalog URL. Falls back to {@link SchemastoreConfigInput.baseUrl} when
+   * omitted; an entry with neither is rejected.
+   */
+  readonly baseUrl?: string;
+  /**
+   * How a versioned document's path/URL nests relative to its base — see
+   * {@link SchemaLayout}. Defaults to `"versioned"` for a custom `baseUrl`,
+   * and is rejected outright under `baseUrl: "schemastore"`, which serves
+   * only the flat layout.
+   */
+  readonly layout?: SchemaLayout;
+  /** Overrides {@link SchemastoreConfigInput.drift} for this schema. */
+  readonly drift?: DriftTolerance;
+  /**
+   * The catalog entry to assemble for this schema. Required under
+   * `baseUrl: "schemastore"` (every SchemaStore-hosted document is
+   * cataloged); optional under a custom host.
+   */
+  readonly catalog?: CatalogInput;
+  /** Forwarded to {@link (SchemaTarget:class).(make:1)}'s `jsonSchema`. */
+  readonly jsonSchema?: Schema.ToJsonSchemaOptions;
+  /** Forwarded to {@link (SchemaTarget:class).(make:1)}'s `rootAnnotations`. */
+  readonly rootAnnotations?: Readonly<Record<string, unknown>>;
+}
+/**
+ * What a `schemastore.config.ts` hands to {@link defineConfig}: a directory
+ * every derived path is written under, top-level defaults for `baseUrl` and
+ * `drift`, and the keyed set of schemas to derive.
  *
  * @public
  */
 interface SchemastoreConfigInput {
-  readonly schemas: ReadonlyArray<SchemaTarget>;
-  readonly catalog?: ReadonlyArray<CatalogConfig>;
-  readonly drift?: Partial<DriftOptions>;
+  /** The directory every derived `path` is written under; a trailing slash is trimmed. */
+  readonly outputDir: string;
+  /** The default {@link SchemaEntryInput.baseUrl} for an entry that declares none. */
+  readonly baseUrl?: string;
+  /** The default {@link SchemaEntryInput.drift} for an entry that declares none. Defaults to `"semantic"`. */
+  readonly drift?: DriftTolerance;
+  /** What a build does when it finds drift. Defaults to `"error"`. */
+  readonly onDrift?: OnDrift;
+  /** Where the assembled catalog is written. Defaults to `<outputDir>/catalog.json`. */
+  readonly catalogPath?: string;
+  /**
+   * The schemas to derive, keyed by file base name — the key IS the
+   * `name` every derived path and URL is built from, so it must be a
+   * simple file base name (no separators, no whitespace).
+   */
+  readonly schemas: Readonly<Record<string, SchemaEntryInput>>;
 }
 /**
- * A validated catalog declaration paired with the `CatalogEntry` assembled
- * from it.
+ * One version of a schema that is advertised (via `versions`) but not the
+ * one currently generated — a file the CLI verifies exists on disk before
+ * any write (existence only — content is never compared), never
+ * regenerates.
  *
  * @public
  */
-interface CatalogTarget {
-  readonly config: CatalogConfig;
-  readonly entry: CatalogEntry;
+interface FrozenVersion {
+  /** The frozen version label. */
+  readonly version: SchemaVersion;
+  /** The path the frozen file lives at. */
+  readonly path: string;
+  /** The catalog URL the frozen file is hosted at. */
+  readonly url: string;
+}
+/**
+ * One `defineConfig` schema entry, resolved: the {@link (SchemaTarget:interface)} to
+ * generate, its frozen predecessor versions, its effective drift tolerance,
+ * and its assembled catalog entry, if any.
+ *
+ * @public
+ */
+interface ResolvedSchema {
+  /** The schema's key in {@link SchemastoreConfigInput.schemas}. */
+  readonly name: string;
+  /** The target to generate at the current version (or the sole, unversioned target). */
+  readonly target: SchemaTarget;
+  /** Every OTHER advertised version, as a frozen file to verify. */
+  readonly frozen: ReadonlyArray<FrozenVersion>;
+  /** This entry's effective drift tolerance, after falling back to the config default. */
+  readonly drift: DriftTolerance;
+  /** The assembled catalog entry, when {@link SchemaEntryInput.catalog} was given. */
+  readonly catalog?: CatalogEntry;
 }
 /**
  * The validated, defaults-filled config {@link defineConfig} answers and the
@@ -1611,23 +1811,47 @@ interface CatalogTarget {
  */
 interface SchemastoreConfig {
   readonly [ConfigBrand]: true;
-  readonly schemas: ReadonlyArray<SchemaTarget>;
-  readonly catalog: ReadonlyArray<CatalogTarget>;
-  readonly drift: DriftOptions;
+  /** The directory every derived `path` is written under, trailing slash trimmed. */
+  readonly outputDir: string;
+  /** What a build does when it finds drift. */
+  readonly onDrift: OnDrift;
+  /** Where the assembled catalog is written. */
+  readonly catalogPath: string;
+  /** Every schema, resolved. */
+  readonly schemas: ReadonlyArray<ResolvedSchema>;
 }
 /**
  * Validate and assemble a `schemastore.config.ts` value.
  *
  * @remarks
- * Pure: no IO, no Effect. Identity-with-validation over the input, filling
- * drift defaults, deriving each catalog entry's `versions` from EVERY
- * versioned schema of that name (published or not — the entry is what gets
- * submitted to become published), and branding the result so a loader can
- * recognise a config module's default export. Throws a plain `Error` on a
- * bad input; the CLI wraps it into its typed config-load error. Rejects an
- * output `path` declared twice across schemas and catalog entries, compared
- * after a lexical normalisation (`./`, `..`, trailing `/`); the CLI's loader
- * re-checks on the resolved absolute paths.
+ * Pure: no IO, no Effect. `$id`, the write `path` and every catalog URL are
+ * derived from ONE layout (`outputDir`, `baseUrl` and `layout`) so they
+ * cannot disagree with each other. `versions` names every label a schema
+ * advertises; `current` (default: the newest under
+ * {@link SchemaVersioning.Order}) is the one generated at `target`, and every
+ * other label becomes a {@link FrozenVersion} the CLI verifies but does not
+ * regenerate. `baseUrl: "schemastore"` expands to
+ * {@link SCHEMASTORE_ID_BASE} for `$id` and {@link SCHEMASTORE_CATALOG_BASE}
+ * for the catalog URL, forcing the `"flat"` layout; any other `baseUrl` is
+ * used as one base for both, defaulting to the `"versioned"` layout.
+ *
+ * Throws a plain `Error` (never a raw `TypeError`) naming the offending
+ * schema on: a non-object `input`; an empty `schemas` record; a
+ * missing/empty `outputDir`; a schema key that is not a simple file base
+ * name; a schema whose `schema` is not an Effect Schema; a schema with no
+ * `baseUrl` anywhere, or a `baseUrl` that is not a string; a `baseUrl` that
+ * is neither `"schemastore"` nor an `https://` URL; a `versions` that is not
+ * an array, or an empty `versions` array; a version label (or `current`)
+ * that is not a string, or an otherwise invalid version label; two labels
+ * spelling the same version; `current` given without `versions`, or naming
+ * one not among them; a non-boolean `published`; `layout` declared under
+ * `baseUrl: "schemastore"`; a missing `catalog` under
+ * `baseUrl: "schemastore"`, or one with an empty `fileMatch`; an invalid
+ * `drift` or top-level `onDrift`; and an output path (a target, a frozen
+ * file, or the catalog path) declared twice, compared after a lexical
+ * normalisation (`./`, `..`, trailing `/`) — the CLI's loader re-checks on
+ * the resolved absolute paths. Branding the result lets a loader recognise a
+ * config module's default export via {@link isSchemastoreConfig}.
  *
  * @public
  */
@@ -1640,5 +1864,5 @@ export declare const defineConfig: (input: SchemastoreConfigInput) => Schemastor
  */
 export declare const isSchemastoreConfig: (value: unknown) => value is SchemastoreConfig;
 //#endregion
-export type { CanonicalJsonError, CanonicalJsonOptions, CatalogConfig, CatalogTarget, CatalogUrls, CheckResult, ContractChangePolicy, DriftOptions, DriftTolerance, DriftVerdict, OnDrift, PipelineCheckResult, PipelineResult, SchemaChange, SchemaFileShape, SchemaPipelineOptions, SchemaValidatorOptions, SchemaValidatorShape, SchemaWriteOptions, SchemastoreConfig, SchemastoreConfigInput, StoreDocumentOptions, WriteChange, WriteOutcome, WriteResult };
+export type { CanonicalJsonError, CanonicalJsonOptions, CatalogInput, CatalogUrls, CheckResult, ContractChangePolicy, DriftOptions, DriftTolerance, DriftVerdict, FrozenVersion, OnDrift, PipelineCheckResult, PipelineResult, ResolvedSchema, SchemaChange, SchemaEntryInput, SchemaFileShape, SchemaLayout, SchemaPipelineOptions, SchemaValidatorOptions, SchemaValidatorShape, SchemaWriteOptions, SchemastoreConfig, SchemastoreConfigInput, StoreDocumentOptions, WriteChange, WriteOutcome, WriteResult };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -9,7 +9,7 @@ import { SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWri
 import { SchemaValidator, SchemaValidatorError, ValidationFinding } from "./SchemaValidator.js";
 import { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument, UndeclaredAnnotationKeyError } from "./StoreDocument.js";
 import { ContractChangeTarget, PipelineFinding, SchemaContractChangeError, SchemaGateError, SchemaPipeline } from "./SchemaPipeline.js";
-import { defineConfig, isSchemastoreConfig } from "./SchemastoreConfig.js";
 import { SchemaTarget } from "./SchemaTarget.js";
+import { SCHEMASTORE_CATALOG_BASE, SCHEMASTORE_ID_BASE, defineConfig, isSchemastoreConfig } from "./SchemastoreConfig.js";
 
-export { CanonicalJson, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, DriftPolicy, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, PipelineFinding, SchemaContractChangeError, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError, SchemaGateError, SchemaPipeline, SchemaTarget, SchemaValidator, SchemaValidatorError, SchemaVersion, SchemaVersioning, StoreDocument, UndeclaredAnnotationKeyError, ValidationFinding, defineConfig, isSchemastoreConfig };
+export { CanonicalJson, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, DriftPolicy, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, PipelineFinding, SCHEMASTORE_CATALOG_BASE, SCHEMASTORE_ID_BASE, SchemaContractChangeError, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError, SchemaGateError, SchemaPipeline, SchemaTarget, SchemaValidator, SchemaValidatorError, SchemaVersion, SchemaVersioning, StoreDocument, UndeclaredAnnotationKeyError, ValidationFinding, defineConfig, isSchemastoreConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/schemastore",
-	"version": "0.9.1",
+	"version": "0.11.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": [