@pagefront/lint-commerce 0.9.0 → 0.11.0

package/dist/sheet-type.d.ts

@@ -15,4 +15,21 @@ import type { Sheet } from "@pagefront/lint-core";
  * page type the catalogue predates dispatch with.
  */
 export type SheetType = "product" | "organization";
+/**
+ * The two lines a sheet can belong to. A sheet on the *release* line
+ * carries `release` and validates against the current sheet-spec
+ * schemas; a sheet on the *legacy* draft line carries `format_version`
+ * (≤ 0.9) and validates against the frozen legacy schemas.
+ */
+export type SheetLine = "release" | "legacy";
+/**
+ * Line detection reads the envelope field first: `release` puts a sheet
+ * on the release line (also when `format_version` is present beside it,
+ * which the release-line schemas and PDP-E-016 / ORG-E-002 reject), and
+ * `format_version` alone puts it on the legacy line. A sheet carrying
+ * neither is placed by its `$schema`: a two-part version segment, or
+ * the pre-2026-09-08 `/schemas/` path, is legacy; anything else is the
+ * release line, whose schema then reports the missing `release`.
+ */
+export declare function detectSheetLine(sheet: Sheet): SheetLine;
 export declare function detectSheetType(sheet: Sheet): SheetType;

package/dist/sheet-type.js

@@ -1,3 +1,28 @@
+/** The legacy line's `$schema` version segment: two parts, `v0.9.json`. */
+const LEGACY_SCHEMA_SEGMENT = /\/v\d+\.\d+\.json$/;
+/**
+ * Line detection reads the envelope field first: `release` puts a sheet
+ * on the release line (also when `format_version` is present beside it,
+ * which the release-line schemas and PDP-E-016 / ORG-E-002 reject), and
+ * `format_version` alone puts it on the legacy line. A sheet carrying
+ * neither is placed by its `$schema`: a two-part version segment, or
+ * the pre-2026-09-08 `/schemas/` path, is legacy; anything else is the
+ * release line, whose schema then reports the missing `release`.
+ */
+export function detectSheetLine(sheet) {
+    if (sheet.release !== undefined)
+        return "release";
+    if (sheet.format_version !== undefined)
+        return "legacy";
+    const schema = sheet.$schema;
+    if (typeof schema === "string") {
+        if (LEGACY_SCHEMA_SEGMENT.test(schema))
+            return "legacy";
+        if (schema.includes("/schemas/organization/") || schema.includes("/schemas/product/"))
+            return "legacy";
+    }
+    return "release";
+}
 const ORG_DATA_TYPES = new Set(["Organization", "OnlineStore", "OnlineBusiness"]);
 export function detectSheetType(sheet) {
     const schema = sheet.$schema;

package/dist/validate-and-lint.d.ts

@@ -5,6 +5,7 @@
  * boundary: callers see `SchemaError`, never Ajv's own error type.
  */
 import type { LintOptions, Report } from "@pagefront/lint-core";
+import type { SheetType } from "./sheet-type.js";
 /**
  * One Layer 1 (JSON Schema) validation failure, in a shape this
  * package owns. `instancePath` is a JSON Pointer to the offending
@@ -24,24 +25,30 @@ export type ValidateAndLintResult = {
     report: Report;
 };
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * product JSON Schema (Layer 1), and — only if it passes — lint it
- * against the commerce rule catalogue (Layer 2). The engine assumes a
- * schema-valid Sheet, so a failing document never reaches the
- * catalogue; Layer 1 success is also what makes the internal cast to
- * `Sheet` sound (the schema requires the envelope fields).
+ * Layer 1 for one document: validate it against the frozen schema its
+ * `$schema` names, or, when it declares none, the schema its own
+ * statements lead to (see schema-registry.ts). Returns the errors, empty
+ * when the document is valid. A `$schema` naming no bundled schema is a
+ * Layer 1 failure of its own, reported at `/$schema` with the keyword
+ * `$schema`: the document is not validated against some other version.
+ */
+export declare function schemaErrorsFor(input: unknown, sheetType?: SheetType): SchemaError[];
+/**
+ * Validate a parsed-but-unvalidated document against a bundled JSON
+ * Schema (Layer 1), and — only if it passes — lint it against the
+ * commerce rule catalogue (Layer 2). The engine assumes a schema-valid
+ * Sheet, so a failing document never reaches the catalogue; Layer 1
+ * success is also what makes the internal cast to `Sheet` sound (the
+ * schema requires the envelope fields).
  *
- * The bundled schemas are the current catalogue's format version. A
- * document declaring some other `format_version` failing Layer 1 is
- * the intended behavior, not a gap: this package lints exactly one
- * format version, and there is no separate "unsupported version"
- * outcome.
+ * The package bundles every schema ever published, on both lines: the
+ * sheet-spec versions of each release, and the legacy draft line's
+ * format 0.9 schemas. A document is validated against the one its
+ * `$schema` names. A `$schema` naming a version this package does not
+ * bundle fails Layer 1 with a single error saying so.
  *
- * Dispatches by page type (see sheet-type.ts): product sheets validate
- * against the product schema and lint with the product catalogue;
- * Commerce Organization Sheets validate against the organization
- * schema and lint with the organization catalogue. Detection reads the
- * envelope `$schema` first, falling back to data-block shape, so a
- * document of either type routes to its own schema's errors.
+ * Layer 2 dispatches by page type (see sheet-type.ts): product sheets
+ * lint with the product catalogue, Commerce Organization Sheets with
+ * the organization catalogue.
  */
 export declare function validateAndLint(input: unknown, options?: LintOptions): ValidateAndLintResult;

package/dist/validate-and-lint.js

@@ -1,41 +1,60 @@
 import { lintSheet } from "./lint-sheet.js";
-import { detectSheetType } from "./sheet-type.js";
-import { validateProduct, validateOrganization } from "./schema-validators.js";
+import { resolveSchema } from "./schema-registry.js";
+import { VALIDATORS } from "./schema-validators.js";
 // The validators are compiled ahead of time (see schema-validators.d.ts):
 // nothing here generates code at load time, so the pipeline runs where
 // eval is unavailable, and consumers calling it in a loop pay no
 // compilation cost.
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * product JSON Schema (Layer 1), and — only if it passes — lint it
- * against the commerce rule catalogue (Layer 2). The engine assumes a
- * schema-valid Sheet, so a failing document never reaches the
- * catalogue; Layer 1 success is also what makes the internal cast to
- * `Sheet` sound (the schema requires the envelope fields).
+ * Layer 1 for one document: validate it against the frozen schema its
+ * `$schema` names, or, when it declares none, the schema its own
+ * statements lead to (see schema-registry.ts). Returns the errors, empty
+ * when the document is valid. A `$schema` naming no bundled schema is a
+ * Layer 1 failure of its own, reported at `/$schema` with the keyword
+ * `$schema`: the document is not validated against some other version.
+ */
+export function schemaErrorsFor(input, sheetType) {
+    const envelope = (typeof input === "object" && input !== null ? input : {});
+    const resolution = resolveSchema(envelope, sheetType);
+    if (resolution.kind === "unknown") {
+        return [
+            {
+                instancePath: "/$schema",
+                message: `names no schema this linter bundles: ${resolution.declared}`,
+                keyword: "$schema",
+            },
+        ];
+    }
+    const validate = VALIDATORS[resolution.id];
+    if (validate(input))
+        return [];
+    return (validate.errors ?? []).map((error) => ({
+        instancePath: error.instancePath,
+        message: error.message ?? "invalid",
+        keyword: error.keyword,
+    }));
+}
+/**
+ * Validate a parsed-but-unvalidated document against a bundled JSON
+ * Schema (Layer 1), and — only if it passes — lint it against the
+ * commerce rule catalogue (Layer 2). The engine assumes a schema-valid
+ * Sheet, so a failing document never reaches the catalogue; Layer 1
+ * success is also what makes the internal cast to `Sheet` sound (the
+ * schema requires the envelope fields).
  *
- * The bundled schemas are the current catalogue's format version. A
- * document declaring some other `format_version` failing Layer 1 is
- * the intended behavior, not a gap: this package lints exactly one
- * format version, and there is no separate "unsupported version"
- * outcome.
+ * The package bundles every schema ever published, on both lines: the
+ * sheet-spec versions of each release, and the legacy draft line's
+ * format 0.9 schemas. A document is validated against the one its
+ * `$schema` names. A `$schema` naming a version this package does not
+ * bundle fails Layer 1 with a single error saying so.
  *
- * Dispatches by page type (see sheet-type.ts): product sheets validate
- * against the product schema and lint with the product catalogue;
- * Commerce Organization Sheets validate against the organization
- * schema and lint with the organization catalogue. Detection reads the
- * envelope `$schema` first, falling back to data-block shape, so a
- * document of either type routes to its own schema's errors.
+ * Layer 2 dispatches by page type (see sheet-type.ts): product sheets
+ * lint with the product catalogue, Commerce Organization Sheets with
+ * the organization catalogue.
  */
 export function validateAndLint(input, options) {
-    const sheetType = detectSheetType((typeof input === "object" && input !== null ? input : {}));
-    const validate = sheetType === "organization" ? validateOrganization : validateProduct;
-    if (!validate(input)) {
-        const schemaErrors = (validate.errors ?? []).map((error) => ({
-            instancePath: error.instancePath,
-            message: error.message ?? "invalid",
-            keyword: error.keyword,
-        }));
+    const schemaErrors = schemaErrorsFor(input);
+    if (schemaErrors.length > 0)
         return { layer: 1, schemaErrors };
-    }
     return { layer: 2, report: lintSheet(input, options) };
 }

package/dist/validate-organization.d.ts

@@ -18,10 +18,10 @@ export type ValidateOrganizationResult = {
     schemaErrors: SchemaError[];
 };
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * Commerce Organization Sheet JSON Schema. The bundled schema is the
- * current format version; a document declaring some other
- * `format_version` failing Layer 1 is the intended behavior, exactly
- * as in the product pipeline.
+ * Validate a parsed-but-unvalidated document against a bundled
+ * Commerce Organization Sheet JSON Schema: the one its `$schema` names,
+ * or, when it declares none, the organization schema for its line (the
+ * sheet-spec version its `release` bundles, or the legacy format 0.9
+ * schema for a sheet carrying `format_version`).
  */
 export declare function validateOrganizationSheet(input: unknown): ValidateOrganizationResult;

package/dist/validate-organization.js

@@ -1,19 +1,12 @@
-import { validateOrganization as validate } from "./schema-validators.js";
+import { schemaErrorsFor } from "./validate-and-lint.js";
 /**
- * Validate a parsed-but-unvalidated document against the bundled
- * Commerce Organization Sheet JSON Schema. The bundled schema is the
- * current format version; a document declaring some other
- * `format_version` failing Layer 1 is the intended behavior, exactly
- * as in the product pipeline.
+ * Validate a parsed-but-unvalidated document against a bundled
+ * Commerce Organization Sheet JSON Schema: the one its `$schema` names,
+ * or, when it declares none, the organization schema for its line (the
+ * sheet-spec version its `release` bundles, or the legacy format 0.9
+ * schema for a sheet carrying `format_version`).
  */
 export function validateOrganizationSheet(input) {
-    if (!validate(input)) {
-        const schemaErrors = (validate.errors ?? []).map((error) => ({
-            instancePath: error.instancePath,
-            message: error.message ?? "invalid",
-            keyword: error.keyword,
-        }));
-        return { valid: false, schemaErrors };
-    }
-    return { valid: true };
+    const schemaErrors = schemaErrorsFor(input, "organization");
+    return schemaErrors.length > 0 ? { valid: false, schemaErrors } : { valid: true };
 }

package/dist/version.d.ts

@@ -5,4 +5,4 @@
  * (test/linter-version.test.mjs) fails when they diverge. Regenerate
  * on version bump.
  */
-export declare const PACKAGE_VERSION = "0.9.0";
+export declare const PACKAGE_VERSION = "0.11.0";

package/dist/version.js

@@ -5,4 +5,4 @@
  * (test/linter-version.test.mjs) fails when they diverge. Regenerate
  * on version bump.
  */
-export const PACKAGE_VERSION = "0.9.0";
+export const PACKAGE_VERSION = "0.11.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagefront/lint-commerce",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Pagefront commerce linter: the commerce rule catalogue and CLI, on the @pagefront/lint-core engine.",
   "license": "Apache-2.0",
   "repository": {
@@ -34,12 +34,12 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc && node scripts/compile-validators.mjs",
+    "build": "node scripts/bundle-schemas.mjs && tsc && node scripts/compile-validators.mjs",
     "test": "npm run build && node --test test/*.test.mjs",
     "prepublishOnly": "npm test"
   },
   "dependencies": {
-    "@pagefront/lint-core": "^0.1.0",
+    "@pagefront/lint-core": "^0.2.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1"
   },

package/dist/organization-schema.d.ts

@@ -1,9 +0,0 @@
-/**
- * The Pagefront Commerce Organization Sheet JSON Schema
- * (commerce/spec/organization.json, format 0.9), bundled verbatim so
- * the published package can run Layer 1 validation without the
- * monorepo checkout. Generated from the spec file; the schema drift
- * test (test/schema.test.mjs) fails when the two diverge. Regenerate
- * on any schema change, in the same change that motivates it.
- */
-export declare const ORGANIZATION_SCHEMA: Record<string, unknown>;