@effected/schemastore 0.17.0 → 0.19.0

package/CatalogEntry.js

@@ -133,7 +133,7 @@ var CatalogEntry = class CatalogEntry extends Schema.Class("CatalogEntry")({
 		return CatalogEntry.lintFileMatch(this.fileMatch);
 	}
 	/**
-	* {@link CatalogEntry.lint} over a bare pattern list, for callers
+	* {@link CatalogEntry.lintFileMatch} over a bare pattern list, for callers
 	* checking patterns before an entry exists.
 	*/
 	static lintFileMatch(patterns) {

package/DriftPolicy.js

@@ -18,6 +18,18 @@ var DriftPolicy = class {
 		policy: "semantic",
 		onDrift: "error"
 	};
+	/**
+	* Answer `"write"` or `"drift"` for one target, given whether it is
+	* published and how its content changed.
+	*
+	* @example
+	* ```ts
+	* import { DriftPolicy } from "@effected/schemastore";
+	*
+	* DriftPolicy.classify({ published: true, change: "contract" }, "semantic");
+	* // => "drift"
+	* ```
+	*/
 	static classify(input, policy) {
 		if (!input.published || policy === "allow") return "write";
 		if (input.change === "contract") return "drift";

package/InstanceValidator.js

@@ -0,0 +1,106 @@
+import { Context, Effect, Layer, Schema } from "effect";
+
+//#region src/InstanceValidator.ts
+/**
+* Indicates that the validation engine behind the {@link InstanceValidator}
+* contract failed as a *mechanism* — it could not run at all.
+*
+* By convention the error channel is reserved for exactly that: an instance
+* that fails the document is an {@link InstanceFinding} list (a value),
+* never an error. A document the engine cannot compile also lands here —
+* unlike {@link SchemaValidatorError}, whose subject IS the document, this
+* contract's subject is the instance, so a document that yields no verdict
+* means the engine could not run against that instance. Raised by
+* implementations of {@link InstanceValidatorShape.validate}.
+*
+* @public
+*/
+var InstanceValidatorError = class extends Schema.TaggedError()("InstanceValidatorError", { 
+/** The underlying engine failure, preserved structurally. */
+cause: Schema.Defect() }) {
+	get message() {
+		return "Instance validation engine failed";
+	}
+};
+/**
+* One problem a validation engine found with an instance: a value in a
+* report, never an error channel — the consumer decides what a finding
+* gates. Structurally the same report {@link ValidationFinding} is for a
+* schema document, but its pointer addresses the INSTANCE, so the two stay
+* separate types: a caller that mixes them up is a compile error, not a
+* silently misread pointer.
+*
+* @public
+*/
+var InstanceFinding = class extends Schema.Class("InstanceFinding")({
+	/** JSON pointer into the instance (`""` is the instance root). */
+	path: Schema.String,
+	/** Human-readable explanation from the engine. */
+	message: Schema.String,
+	/** The JSON Schema keyword the finding is about, when the engine names one. */
+	keyword: Schema.optionalKey(Schema.String)
+}) {};
+/** The default for an unstubbed {@link InstanceValidator.makeTest} member. */
+const notStubbed = (method) => () => Effect.die(/* @__PURE__ */ new Error(`InstanceValidator.makeTest: ${method}() was called but not stubbed — no honest default exists for a test double; pass a \`${method}\` override.`));
+/**
+* The payload-against-document validation contract — the question
+* {@link SchemaValidator} does not answer: not "is this document valid JSON
+* Schema", but "does this instance conform to the published document it
+* names in `$schema`". Decoding with the source Effect Schema is not a
+* substitute: that proves the instance matches the CODE, not the committed
+* document consumers actually fetch, and the two can drift.
+*
+* Like {@link SchemaValidator}, this package ships the contract and its
+* doubles only: skip validation with {@link InstanceValidator.noop}, stub it
+* with {@link InstanceValidator.layerTest}. The one real implementation is
+* `@effected/schemastore-cli`'s `AjvInstanceValidator.layer` — the same ajv
+* strict-mode setup `AjvValidator` gates documents with, pointed at an
+* instance — which the `schemastore validate` command composes for you and
+* which that package also exports for a program that drives the contract
+* itself. Keeping the engine there keeps `ajv` out of every application
+* that imports this package at runtime.
+*
+* @example
+* ```ts
+* import { InstanceValidator } from "@effected/schemastore";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const validator = yield* InstanceValidator;
+*   return yield* validator.validate({ type: "object" }, { any: "payload" });
+* });
+*
+* // Provide the engine at the edge — the CLI does this for you:
+* //   Effect.provide(program, AjvInstanceValidator.layer)   (from @effected/schemastore-cli)
+* Effect.runPromise(Effect.provide(program, InstanceValidator.noop));
+* // => []
+* ```
+*
+* @public
+*/
+var InstanceValidator = class InstanceValidator extends Context.Service()("@effected/schemastore/InstanceValidator") {
+	/**
+	* No-op: `validate` always succeeds with no findings, never consulting an
+	* engine. A pure `Layer.succeed`, bound to a const so the layer memoizes
+	* by reference. Use it to switch validation off deliberately — for the
+	* real engine, provide `AjvInstanceValidator.layer` from
+	* `@effected/schemastore-cli`.
+	*/
+	static noop = Layer.succeed(InstanceValidator, { validate: () => Effect.succeed([]) });
+	/**
+	* An in-memory double: stub only the members the test exercises; every
+	* other member **dies** with a defect naming itself. No member has an
+	* honest default — a fabricated clean pass would leak into consumer
+	* logic as fact (use {@link InstanceValidator.noop} when a test genuinely
+	* wants an always-clean validator).
+	*/
+	static makeTest = (overrides = {}) => ({
+		validate: notStubbed("validate"),
+		...overrides
+	});
+	/** {@link InstanceValidator.makeTest} behind `Layer.succeed`. */
+	static layerTest = (overrides = {}) => Layer.succeed(InstanceValidator, InstanceValidator.makeTest(overrides));
+};
+
+//#endregion
+export { InstanceFinding, InstanceValidator, InstanceValidatorError };

package/README.md

@@ -7,10 +7,10 @@
 
 Publish Effect Schemas as SchemaStore-shaped Draft-07 JSON Schema documents. Core `effect` already generates JSON Schema (`Schema.toJsonSchemaDocument`) and lowers it to Draft-07 (`JsonSchema.toDocumentDraft07`); this package owns what [SchemaStore](https://www.schemastore.org) and the editors expect around that output — the publication shape, the hosted identity a document is published under, the keyword-family gate, catalog entries, lints, versioning, canonical JSON and content-comparing file IO — and the [`schemastore`](https://www.npmjs.com/package/@effected/schemastore-cli) command runs all of it from one config file.
 
-> **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
-> `1.0.0` once Effect `4.0.0` ships. To hold your own `effect` versions at
-> exactly the ones the kit is built and tested against, install
+> **Pre-`1.0.0`.** This package is part of the `@effected/*` kit, built on stable
+> Effect v4 (`effect` `^4.0.0`) and still in `0.x` development. Stable Effect
+> makes a kit `1.0.0` possible, not automatic. To keep your `effect` and
+> `@effect/*` versions on the line the kit is built and tested against, install
 > [`@effected/pnpm-plugin-effect`](https://www.npmjs.com/package/@effected/pnpm-plugin-effect).
 >
 > **Stability: unstable.** This package's API surface is not yet considered

package/SchemaPipeline.js

@@ -116,7 +116,7 @@ const gate = (target, findings, options) => {
 };
 /**
 * The emit pipeline over a target manifest: generate, lint, validate, gate,
-* write — the loop every consumer of this package was writing by hand.
+* and write each schema document.
 *
 * Requires `SchemaFile` and `SchemaValidator` in `R`; provide
 * `SchemaFile.layer` and an engine — `AjvValidator.layer` from

package/SchemastoreConfig.js

@@ -209,6 +209,21 @@ const assertUniquePaths = (paths) => {
 * re-checks on the resolved absolute paths. Branding the result lets a loader recognise a config
 * module's default export via {@link isSchemastoreConfig}.
 *
+* @example
+* ```ts
+* import { defineConfig } from "@effected/schemastore";
+* import { Schema } from "effect";
+*
+* const Config = Schema.Struct({ name: Schema.String });
+*
+* export default defineConfig({
+* 	name: "my-tool",
+* 	outputDir: "schemas",
+* 	baseUrl: "https://example.com/schemas",
+* 	schemas: { config: { schema: Config } },
+* });
+* ```
+*
 * @public
 */
 const defineConfig = (input) => {

package/StoreDocument.js

@@ -7,8 +7,7 @@ import { Effect, JsonPointer, JsonSchema, Result, Schema } from "effect";
 * The Draft-07 meta-schema URL SchemaStore documents declare as `$schema`.
 *
 * Deliberately carries the trailing `#` fragment: the SchemaStore corpus
-* (and the extraction source's committed files) use the fragment form,
-* where core's `JsonSchema.META_SCHEMA_URI_DRAFT_07` omits it.
+* uses the fragment form, where core's `JsonSchema.META_SCHEMA_URI_DRAFT_07` omits it.
 *
 * @public
 */
@@ -185,7 +184,7 @@ const collapseUniformTuples = (node, depth) => {
 * `#/$defs` `$ref` rewrite the lowering makes necessary — so every `$ref`
 * in a built document already resolves against the `$defs` pool — the
 * uniform-tuple collapse that keeps open-ended `NonEmptyArray`-shaped
-* arrays publishable through the strict ajv gate (#818), and the gate that
+* arrays publishable through the strict ajv gate, and the 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.
@@ -299,8 +298,7 @@ var StoreDocument = class StoreDocument extends Schema.Class("StoreDocument")({
 	/**
 	* The flat SchemaStore publication shape: `$schema`, `$id`, the root
 	* schema's keywords spread at the top level, then the `$defs` pool.
-	* `$defs` is omitted when the pool is empty (a deliberate divergence
-	* from the extraction source, which always emitted the key).
+	* `$defs` is omitted when the pool is empty.
 	*/
 	toJson() {
 		return {

package/index.d.ts

@@ -52,8 +52,8 @@ type CanonicalJsonError = NonJsonValueError | JsonDepthExceededError;
  */
 interface CanonicalJsonOptions {
   /**
-   * Indentation unit: `"tab"` (the default, matching the repo formatter
-   * convention the extraction source committed its files under) or a
+   * Indentation unit: `"tab"` (the default, matching the formatter
+   * convention of most JSON schema repos) or a
    * space count — a non-negative integer (`0` emits multi-line output
    * with no leading indentation). Counts above 10 are honored as given,
    * deliberately diverging from `JSON.stringify`'s silent clamp to 10.
@@ -195,8 +195,7 @@ export declare class DocumentDiff {
  * The Draft-07 meta-schema URL SchemaStore documents declare as `$schema`.
  *
  * Deliberately carries the trailing `#` fragment: the SchemaStore corpus
- * (and the extraction source's committed files) use the fragment form,
- * where core's `JsonSchema.META_SCHEMA_URI_DRAFT_07` omits it.
+ * uses the fragment form, where core's `JsonSchema.META_SCHEMA_URI_DRAFT_07` omits it.
  *
  * @public
  */
@@ -341,7 +340,7 @@ declare const StoreDocument_base: Schema.Class<StoreDocument, Schema.Struct<{
  * `#/$defs` `$ref` rewrite the lowering makes necessary — so every `$ref`
  * in a built document already resolves against the `$defs` pool — the
  * uniform-tuple collapse that keeps open-ended `NonEmptyArray`-shaped
- * arrays publishable through the strict ajv gate (#818), and the gate that
+ * arrays publishable through the strict ajv gate, and the 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.
@@ -404,8 +403,7 @@ export declare class StoreDocument extends StoreDocument_base {
   /**
    * The flat SchemaStore publication shape: `$schema`, `$id`, the root
    * schema's keywords spread at the top level, then the `$defs` pool.
-   * `$defs` is omitted when the pool is empty (a deliberate divergence
-   * from the extraction source, which always emitted the key).
+   * `$defs` is omitted when the pool is empty.
    */
   toJson(): Record<string, unknown>;
   /**
@@ -913,7 +911,7 @@ export declare class CatalogEntry extends CatalogEntry_base {
    */
   lint(): ReadonlyArray<CatalogLintFinding>;
   /**
-   * {@link CatalogEntry.lint} over a bare pattern list, for callers
+   * {@link CatalogEntry.lintFileMatch} over a bare pattern list, for callers
    * checking patterns before an entry exists.
    */
   static lintFileMatch(patterns: ReadonlyArray<string>): ReadonlyArray<CatalogLintFinding>;
@@ -1001,7 +999,9 @@ type OnDrift = "error" | "warn";
  * @public
  */
 interface DriftOptions {
+  /** How much change a published document may absorb. */
   readonly policy: DriftTolerance;
+  /** What a build does when it finds drift. */
   readonly onDrift: OnDrift;
 }
 /**
@@ -1026,6 +1026,18 @@ export declare class DriftPolicy {
   private constructor();
   /** `{ policy: "semantic", onDrift: "error" }` — what a config gets when it says nothing. */
   static readonly defaults: DriftOptions;
+  /**
+   * Answer `"write"` or `"drift"` for one target, given whether it is
+   * published and how its content changed.
+   *
+   * @example
+   * ```ts
+   * import { DriftPolicy } from "@effected/schemastore";
+   *
+   * DriftPolicy.classify({ published: true, change: "contract" }, "semantic");
+   * // => "drift"
+   * ```
+   */
   static classify(input: {
     readonly published: boolean;
     readonly change: WriteChange;
@@ -1161,6 +1173,135 @@ export declare class HostedSchema extends HostedSchema_base {
   private parseLabel;
 }
 //#endregion
+//#region src/InstanceValidator.d.ts
+declare const InstanceValidatorError_base: Schema.Class<InstanceValidatorError, Schema.TaggedStruct<"InstanceValidatorError", {
+  /** The underlying engine failure, preserved structurally. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that the validation engine behind the {@link InstanceValidator}
+ * contract failed as a *mechanism* — it could not run at all.
+ *
+ * By convention the error channel is reserved for exactly that: an instance
+ * that fails the document is an {@link InstanceFinding} list (a value),
+ * never an error. A document the engine cannot compile also lands here —
+ * unlike {@link SchemaValidatorError}, whose subject IS the document, this
+ * contract's subject is the instance, so a document that yields no verdict
+ * means the engine could not run against that instance. Raised by
+ * implementations of {@link InstanceValidatorShape.validate}.
+ *
+ * @public
+ */
+export declare class InstanceValidatorError extends InstanceValidatorError_base {
+  get message(): string;
+}
+declare const InstanceFinding_base: Schema.Class<InstanceFinding, Schema.Struct<{
+  /** JSON pointer into the instance (`""` is the instance root). */
+  readonly path: Schema.String;
+  /** Human-readable explanation from the engine. */
+  readonly message: Schema.String;
+  /** The JSON Schema keyword the finding is about, when the engine names one. */
+  readonly keyword: Schema.optionalKey<Schema.String>;
+}>, {}>;
+/**
+ * One problem a validation engine found with an instance: a value in a
+ * report, never an error channel — the consumer decides what a finding
+ * gates. Structurally the same report {@link ValidationFinding} is for a
+ * schema document, but its pointer addresses the INSTANCE, so the two stay
+ * separate types: a caller that mixes them up is a compile error, not a
+ * silently misread pointer.
+ *
+ * @public
+ */
+export declare class InstanceFinding extends InstanceFinding_base {}
+/**
+ * Options for {@link InstanceValidatorShape.validate}.
+ *
+ * @public
+ */
+interface InstanceValidatorOptions {
+  /**
+   * Whether the engine runs its strictest mode (ajv `strict: true` — the
+   * SchemaStore default gate) when compiling the document. Defaults to
+   * `true`; implementations treat an omitted value as strict.
+   */
+  readonly strict?: boolean;
+}
+/**
+ * The shape of the {@link InstanceValidator} service — what an implementation
+ * provides.
+ *
+ * @public
+ */
+interface InstanceValidatorShape {
+  /**
+   * Validates an arbitrary JSON instance against a schema document with a
+   * real JSON Schema engine. An empty array is a clean pass; an instance
+   * the document rejects answers findings as values, each carrying a JSON
+   * pointer into the instance. The error channel is reserved for the
+   * engine failing as a mechanism ({@link InstanceValidatorError}),
+   * including a document the engine cannot compile.
+   */
+  readonly validate: (document: Record<string, unknown>, instance: unknown, options?: InstanceValidatorOptions) => Effect.Effect<ReadonlyArray<InstanceFinding>, InstanceValidatorError>;
+}
+declare const InstanceValidator_base: Context.ServiceClass<InstanceValidator, "@effected/schemastore/InstanceValidator", InstanceValidatorShape>;
+/**
+ * The payload-against-document validation contract — the question
+ * {@link SchemaValidator} does not answer: not "is this document valid JSON
+ * Schema", but "does this instance conform to the published document it
+ * names in `$schema`". Decoding with the source Effect Schema is not a
+ * substitute: that proves the instance matches the CODE, not the committed
+ * document consumers actually fetch, and the two can drift.
+ *
+ * Like {@link SchemaValidator}, this package ships the contract and its
+ * doubles only: skip validation with {@link InstanceValidator.noop}, stub it
+ * with {@link InstanceValidator.layerTest}. The one real implementation is
+ * `@effected/schemastore-cli`'s `AjvInstanceValidator.layer` — the same ajv
+ * strict-mode setup `AjvValidator` gates documents with, pointed at an
+ * instance — which the `schemastore validate` command composes for you and
+ * which that package also exports for a program that drives the contract
+ * itself. Keeping the engine there keeps `ajv` out of every application
+ * that imports this package at runtime.
+ *
+ * @example
+ * ```ts
+ * import { InstanceValidator } from "@effected/schemastore";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const validator = yield* InstanceValidator;
+ *   return yield* validator.validate({ type: "object" }, { any: "payload" });
+ * });
+ *
+ * // Provide the engine at the edge — the CLI does this for you:
+ * //   Effect.provide(program, AjvInstanceValidator.layer)   (from @effected/schemastore-cli)
+ * Effect.runPromise(Effect.provide(program, InstanceValidator.noop));
+ * // => []
+ * ```
+ *
+ * @public
+ */
+export declare class InstanceValidator extends InstanceValidator_base {
+  /**
+   * No-op: `validate` always succeeds with no findings, never consulting an
+   * engine. A pure `Layer.succeed`, bound to a const so the layer memoizes
+   * by reference. Use it to switch validation off deliberately — for the
+   * real engine, provide `AjvInstanceValidator.layer` from
+   * `@effected/schemastore-cli`.
+   */
+  static readonly noop: Layer.Layer<InstanceValidator>;
+  /**
+   * An in-memory double: stub only the members the test exercises; every
+   * other member **dies** with a defect naming itself. No member has an
+   * honest default — a fabricated clean pass would leak into consumer
+   * logic as fact (use {@link InstanceValidator.noop} when a test genuinely
+   * wants an always-clean validator).
+   */
+  static readonly makeTest: (overrides?: Partial<InstanceValidatorShape>) => InstanceValidatorShape;
+  /** {@link InstanceValidator.makeTest} behind `Layer.succeed`. */
+  static readonly layerTest: (overrides?: Partial<InstanceValidatorShape>) => Layer.Layer<InstanceValidator>;
+}
+//#endregion
 //#region src/KeywordFamilies.d.ts
 /**
  * The one owner of the declared non-standard keyword families, in two
@@ -1246,8 +1387,7 @@ export declare class KeywordFamilies {
 /**
  * A single schema publication target: an Effect Schema source paired with
  * the identity and destination it is serialized under. A repo generating
- * SchemaStore artifacts declares one target per emitted document (the
- * extraction source's `{schema, $id, path}` triples, generalized).
+ * SchemaStore artifacts declares one target per emitted document.
  *
  * Not a `Schema.Class`: a target carries a live Effect Schema value, which
  * is program wiring rather than serializable data.
@@ -1263,9 +1403,7 @@ export interface SchemaTarget {
    * The catalog/file base name (`name.json` / `name-<version>.json`).
    *
    * Only the catalog path consumes it — a target that merely emits a file
-   * to `path` needs no name, and inventing one to
-   * satisfy the constructor duplicates the basename with no invariant
-   * tying the two together. Required whenever `version` is present, since
+   * to `path` needs no name. Required whenever `version` is present, since
    * versioned catalog naming is defined in terms of it.
    */
   readonly name?: string;
@@ -1538,8 +1676,7 @@ export declare class SchemaGateError extends SchemaGateError_base {
  *   any write. A target with no `version`, or with a prerelease label, is a
  *   document that replaces its predecessor in place and is rewritten as
  *   before.
- * - `"allow"` — classify and report only, never refuse: the pre-guard
- *   behaviour. Also the sanctioned REPAIR path for a published file whose
+ * - `"allow"` — classify and report only, never refuse. Also the sanctioned REPAIR path for a published file whose
  *   text no longer parses — `SchemaFile` classifies unparseable text as
  *   `"contract"` so it stays regenerable, and under the default that
  *   classification is refused.
@@ -1686,7 +1823,7 @@ interface SchemaPipelineOptions {
 }
 /**
  * The emit pipeline over a target manifest: generate, lint, validate, gate,
- * write — the loop every consumer of this package was writing by hand.
+ * and write each schema document.
  *
  * Requires `SchemaFile` and `SchemaValidator` in `R`; provide
  * `SchemaFile.layer` and an engine — `AjvValidator.layer` from
@@ -1916,9 +2053,10 @@ interface SchemastoreConfigInput {
    * file in it is read as a slice, so it holds nothing else, must not be
    * `outputDir` itself, and must not be the merged catalog's own path.
    * Every config that shares a merged catalog must share the same
-   * `catalogDir`, under a `name` unique case-insensitively among them: two sibling directories (`schemas/catalogs`,
-   * `schemas/more`) both merge into `schemas/catalog.json` from different
-   * slice sets and overwrite each other — no single config can detect it.
+   * `catalogDir`, under a `name` unique case-insensitively among them: two
+   * sibling directories (`schemas/catalogs`, `schemas/more`) both merge into
+   * `schemas/catalog.json` from different slice sets and overwrite each
+   * other — no single config can detect it.
    */
   readonly catalogDir?: string;
   /**
@@ -2022,6 +2160,21 @@ interface SchemastoreConfig {
  * re-checks on the resolved absolute paths. Branding the result lets a loader recognise a config
  * module's default export via {@link isSchemastoreConfig}.
  *
+ * @example
+ * ```ts
+ * import { defineConfig } from "@effected/schemastore";
+ * import { Schema } from "effect";
+ *
+ * const Config = Schema.Struct({ name: Schema.String });
+ *
+ * export default defineConfig({
+ * 	name: "my-tool",
+ * 	outputDir: "schemas",
+ * 	baseUrl: "https://example.com/schemas",
+ * 	schemas: { config: { schema: Config } },
+ * });
+ * ```
+ *
  * @public
  */
 export declare const defineConfig: (input: SchemastoreConfigInput) => SchemastoreConfig;
@@ -2033,5 +2186,5 @@ export declare const defineConfig: (input: SchemastoreConfigInput) => Schemastor
  */
 export declare const isSchemastoreConfig: (value: unknown) => value is SchemastoreConfig;
 //#endregion
-export type { CanonicalJsonError, CanonicalJsonOptions, CatalogInput, CatalogUrls, CheckResult, ContractChangePolicy, CustomHostedSchemaInput, DriftOptions, DriftTolerance, DriftVerdict, FrozenVersion, GitHubHostedSchemaInput, HostedSchemaVersionsInput, OnDrift, PipelineCheckResult, PipelineResult, ResolvedSchema, SchemaChange, SchemaEntryInput, SchemaFileShape, SchemaLayout, SchemaPipelineOptions, SchemaValidatorOptions, SchemaValidatorShape, SchemaWriteOptions, SchemastoreConfig, SchemastoreConfigInput, StoreDocumentOptions, WriteChange, WriteOutcome, WriteResult };
+export type { CanonicalJsonError, CanonicalJsonOptions, CatalogInput, CatalogUrls, CheckResult, ContractChangePolicy, CustomHostedSchemaInput, DriftOptions, DriftTolerance, DriftVerdict, FrozenVersion, GitHubHostedSchemaInput, HostedSchemaVersionsInput, InstanceValidatorOptions, InstanceValidatorShape, 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

@@ -6,6 +6,7 @@ import { DocumentDiff } from "./DocumentDiff.js";
 import { DocumentLint, DocumentLintFinding } from "./DocumentLint.js";
 import { DriftPolicy } from "./DriftPolicy.js";
 import { HostedSchema, SCHEMASTORE_CATALOG_BASE, SCHEMASTORE_ID_BASE } from "./HostedSchema.js";
+import { InstanceFinding, InstanceValidator, InstanceValidatorError } from "./InstanceValidator.js";
 import { SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError } from "./SchemaFile.js";
 import { SchemaValidator, SchemaValidatorError, ValidationFinding } from "./SchemaValidator.js";
 import { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument, UndeclaredAnnotationKeyError } from "./StoreDocument.js";
@@ -13,4 +14,4 @@ import { ContractChangeTarget, PipelineFinding, SchemaContractChangeError, Schem
 import { SchemaTarget } from "./SchemaTarget.js";
 import { defineConfig, isSchemastoreConfig } from "./SchemastoreConfig.js";
 
-export { CanonicalJson, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, DriftPolicy, HostedSchema, 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 };
+export { CanonicalJson, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, DriftPolicy, HostedSchema, InstanceFinding, InstanceValidator, InstanceValidatorError, 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.17.0",
+	"version": "0.19.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,10 +38,10 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/semver": "^0.10.1"
+		"@effected/semver": "^0.11.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.118"
+		"effect": "^4.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"