@vtex/faststore 0.0.1

package/dist/core/dist/actions/mock-action.js

@@ -0,0 +1,28 @@
+//#region ../core/dist/actions/mock-action.js
+/**
+* Builds a typed `$actions` value for a selector without going through the compiler wrapper, so
+* Storybook, unit tests, and manual JSX can render components that declare `actions` — the
+* defense-in-depth path the actions RFC mandates ($actions is the only sanctioned write surface
+* for the compiler, but handlers stay directly callable off the compiled path).
+*
+* Any method in the selector without a provided implementation falls back to a no-op that resolves
+* to an empty `userErrors` array, so a test that only cares about one method need not stub the rest.
+*
+* @example
+* const $actions = mockAction({ cart: ['addItem'] }, { cart: { addItem: vi.fn() } });
+* render(<AddToCartButton $actions={$actions} />);
+*/
+function mockAction(selector, impl = {}) {
+	const actions = {};
+	for (const [namespace, methods] of Object.entries(selector)) {
+		const providedForNamespace = impl[namespace] ?? {};
+		const methodMap = {};
+		for (const method of methods ?? []) methodMap[method] = providedForNamespace[method] ?? (() => Promise.resolve([]));
+		actions[namespace] = methodMap;
+	}
+	return actions;
+}
+//#endregion
+export { mockAction };
+
+//# sourceMappingURL=mock-action.js.map

package/dist/core/dist/actions/mock-action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-action.js","names":[],"sources":["../../../../../core/dist/actions/mock-action.js"],"sourcesContent":["/**\n * Builds a typed `$actions` value for a selector without going through the compiler wrapper, so\n * Storybook, unit tests, and manual JSX can render components that declare `actions` — the\n * defense-in-depth path the actions RFC mandates ($actions is the only sanctioned write surface\n * for the compiler, but handlers stay directly callable off the compiled path).\n *\n * Any method in the selector without a provided implementation falls back to a no-op that resolves\n * to an empty `userErrors` array, so a test that only cares about one method need not stub the rest.\n *\n * @example\n * const $actions = mockAction({ cart: ['addItem'] }, { cart: { addItem: vi.fn() } });\n * render(<AddToCartButton $actions={$actions} />);\n */\nexport function mockAction(selector, impl = {}) {\n    const actions = {};\n    for (const [namespace, methods] of Object.entries(selector)) {\n        const providedForNamespace = impl[namespace] ?? {};\n        const methodMap = {};\n        for (const method of methods ?? []) {\n            methodMap[method] = providedForNamespace[method] ?? (() => Promise.resolve([]));\n        }\n        actions[namespace] = methodMap;\n    }\n    return actions;\n}\n//# sourceMappingURL=mock-action.js.map"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,WAAW,UAAU,OAAO,CAAC,GAAG;CAC5C,MAAM,UAAU,CAAC;CACjB,KAAK,MAAM,CAAC,WAAW,YAAY,OAAO,QAAQ,QAAQ,GAAG;EACzD,MAAM,uBAAuB,KAAK,cAAc,CAAC;EACjD,MAAM,YAAY,CAAC;EACnB,KAAK,MAAM,UAAU,WAAW,CAAC,GAC7B,UAAU,UAAU,qBAAqB,kBAAkB,QAAQ,QAAQ,CAAC,CAAC;EAEjF,QAAQ,aAAa;CACzB;CACA,OAAO;AACX"}

package/dist/core/dist/actions/registry.d.ts

@@ -0,0 +1,24 @@
+//#region ../core/dist/actions/registry.d.ts
+/**
+ * First-party action model — the write-side counterpart to the data layer's read side
+ * (docs/storefront-core/rfc-actions.md, docs/storefront-core/adr-0010-actions-own-the-write-side.md).
+ *
+ * `defineActions` is the single source of truth for an action namespace, exactly as `defineComponent`
+ * is for a component. A first-party module (co-located with the namespace's `use` hook) declares the
+ * namespace, its method/payload metadata, the runtime provider binding, and the hook in one place.
+ * The native catalog builder (`@vtex/sukima-node`'s `buildPackageCatalog`) scans those call sites
+ * and emits `actions.json` (compiler-facing), mirroring how it emits `catalog.json` from
+ * `defineComponent`.
+ *
+ * There is no hardcoded namespace list here: fs-core ships the *types* and the factory, never the
+ * catalog data. The catalog is whatever the first-party `defineActions` calls declare (v1: `cart`).
+ */
+/**
+ * Write-side selector declared on `defineComponent`: a flat map from namespace to method names. Both
+ * namespace keys and method names are plain strings, validated at build time by
+ * `validateActionConstraints` in the sukima compiler against the generated action catalog —
+ * exactly like `requiresContext` is validated by `validateContextConstraints`.
+ */
+export type ActionSelector = Record<string, readonly string[]>;
+//#endregion
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/dist/actions/registry.js

@@ -0,0 +1,28 @@
+//#region ../core/dist/actions/registry.js
+/**
+* First-party action model — the write-side counterpart to the data layer's read side
+* (docs/storefront-core/rfc-actions.md, docs/storefront-core/adr-0010-actions-own-the-write-side.md).
+*
+* `defineActions` is the single source of truth for an action namespace, exactly as `defineComponent`
+* is for a component. A first-party module (co-located with the namespace's `use` hook) declares the
+* namespace, its method/payload metadata, the runtime provider binding, and the hook in one place.
+* The native catalog builder (`@vtex/sukima-node`'s `buildPackageCatalog`) scans those call sites
+* and emits `actions.json` (compiler-facing), mirroring how it emits `catalog.json` from
+* `defineComponent`.
+*
+* There is no hardcoded namespace list here: fs-core ships the *types* and the factory, never the
+* catalog data. The catalog is whatever the first-party `defineActions` calls declare (v1: `cart`).
+*/
+/**
+* Declares a first-party action namespace. Pure identity, like `defineComponent`: it returns the
+* definition unchanged so the runtime can call `use`, while the build-time generator statically reads
+* the metadata off the call site. Internal — extensions never call this; they consume the selector
+* only and can never add a namespace.
+*/
+function defineActions(definition) {
+	return definition;
+}
+//#endregion
+export { defineActions };
+
+//# sourceMappingURL=registry.js.map

package/dist/core/dist/actions/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../../../../core/dist/actions/registry.js"],"sourcesContent":["/**\n * First-party action model — the write-side counterpart to the data layer's read side\n * (docs/storefront-core/rfc-actions.md, docs/storefront-core/adr-0010-actions-own-the-write-side.md).\n *\n * `defineActions` is the single source of truth for an action namespace, exactly as `defineComponent`\n * is for a component. A first-party module (co-located with the namespace's `use` hook) declares the\n * namespace, its method/payload metadata, the runtime provider binding, and the hook in one place.\n * The native catalog builder (`@vtex/sukima-node`'s `buildPackageCatalog`) scans those call sites\n * and emits `actions.json` (compiler-facing), mirroring how it emits `catalog.json` from\n * `defineComponent`.\n *\n * There is no hardcoded namespace list here: fs-core ships the *types* and the factory, never the\n * catalog data. The catalog is whatever the first-party `defineActions` calls declare (v1: `cart`).\n */\n/**\n * Declares a first-party action namespace. Pure identity, like `defineComponent`: it returns the\n * definition unchanged so the runtime can call `use`, while the build-time generator statically reads\n * the metadata off the call site. Internal — extensions never call this; they consume the selector\n * only and can never add a namespace.\n */\nexport function defineActions(definition) {\n    return definition;\n}\n//# sourceMappingURL=registry.js.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,cAAc,YAAY;CACtC,OAAO;AACX"}

package/dist/core/dist/define-component.d.ts

@@ -0,0 +1,100 @@
+import { ActionSelector } from "./actions/registry.js";
+import { ContentTypeDefinition, ContentValue } from "./define-content-type.js";
+import { ComponentType } from "react";
+import { DocumentNode } from "graphql";
+//#region ../core/dist/define-component.d.ts
+export interface EditorMetadata {
+  label: string;
+  category: string;
+  description?: string;
+  icon?: string;
+}
+export type PropType = 'string' | 'number' | 'boolean' | 'object' | 'array' | readonly string[];
+export type PropSchemaField = {
+  /**
+   * Prop type keyword. The catalog wire value `"icon"` is a sukima convention (collected at
+   * compile time); it is a plain string here, not a branded PropType member.
+   */
+  type: PropType | (string & {});
+  /**
+   * Allowed element values, honored only when `type === 'array'`: validates an array-of-enum prop
+   * (e.g. `{ type: 'array', items: ['anonymous', 'identified', 'loggedIn'] as const }`) — the value
+   * must be an array AND every element must be in this set. Omit for an untyped array (any element).
+   */
+  items?: readonly string[];
+  default?: unknown;
+  label?: string;
+};
+export type PropSchema = Record<string, PropSchemaField>;
+export type FetchStrategy = 'static' | 'lazy' | 'reactive' | 'reactive-list-item';
+export interface ComponentDefinition<TProps = Record<string, unknown>> {
+  name: string;
+  importPath: string;
+  component: ComponentType<TProps>;
+  editor: EditorMetadata;
+  schema: PropSchema;
+  fragment?: string | DocumentNode;
+  fetchStrategy?: FetchStrategy;
+  skeleton?: ComponentType;
+  guideline?: string;
+  docPath?: string;
+  /**
+   * Context names this component **provides** to its descendants. Pair with `requiresContext`
+   * on consumers — the schema compiler asserts that every required context is provided by some
+   * ancestor of the consuming element. Use a stable string identifier (e.g.
+   * `'product-information'`, `'cart'`) tied to the React context the component owns; many
+   * implementations of the same contract (`ProductInformationRoot`, `B2BProductInformationRoot`)
+   * can declare the same value. Pass a single string for the common case or an array when one
+   * provider owns multiple contexts. Omit when the component provides none.
+   */
+  providesContext?: string | string[];
+  /**
+   * Context names this component **requires** to be provided by some ancestor when the schema
+   * compiler validates a page or layout. The check is contract-based, not name-based: any
+   * ancestor whose definition declares the same value under `providesContext` satisfies the
+   * requirement (so a `B2BProductInformationRoot` substitutes for `ProductInformationRoot`
+   * without editing consumers). Pass a single string for the common case
+   * (`'product-information'`) or an array when more than one context is required. Omit to skip
+   * the check entirely (default).
+   *
+   * Enforced at build time by `validateContextConstraints` in the sukima compiler. Runtime
+   * context guards inside components remain in place as defense-in-depth for consumers that
+   * bypass the compiler (Storybook, tests, manual JSX).
+   */
+  requiresContext?: string | string[];
+  /**
+   * Write-side dependency declaration: the action namespaces and methods this component dispatches.
+   * The compiler resolves each key against the first-party action catalog (`actions.json`, generated
+   * from `defineActions`), validates it, and threads a narrowed `$actions` prop into the component —
+   * the write-side mirror of `fragment` -> `$data`. Because the selector is declared here,
+   * `catalog.json` records exactly which actions each component touches as static data.
+   *
+   * Namespace keys and method names are plain strings validated at build time by
+   * `validateActionConstraints` in the sukima compiler (typo-style errors with candidate
+   * suggestions), mirroring how `requiresContext` is validated rather than type-checked. Omit when
+   * the component performs no writes. Extensions consume the selector but can never add a namespace.
+   */
+  actions?: ActionSelector;
+  /**
+   * Zero-or-one content model consumed as `$content` (content-only CMS integration). A component
+   * with a model receives merchant-authored editorial values; the compiler slices them out of the
+   * page's or layout's composite entry by the element's own id. Element-level placement and the
+   * page/layout locator are the compiler's concern; this field only fixes the declaration shape.
+   */
+  content?: ContentTypeDefinition;
+}
+/**
+ * When a `content` model is declared, the component's `$content` prop must be assignable to the
+ * model-derived value; a mismatch resolves to a marker that makes `content` impossible to pass, so
+ * the correlation is enforced at the definition site. Components without a model are unaffected.
+ */
+type CorrelateContent<TProps, TContent extends ContentTypeDefinition> = [TProps extends {
+  $content?: infer C;
+} ? C : undefined] extends [ContentValue<TContent> | undefined] ? unknown : {
+  content: 'the $content prop is not assignable to ContentValue<the declared content model>';
+};
+export declare function defineComponent<TProps = Record<string, unknown>, const TContent extends ContentTypeDefinition = ContentTypeDefinition>(definition: ComponentDefinition<TProps> & {
+  content?: TContent;
+} & CorrelateContent<TProps, TContent>): ComponentDefinition<TProps>;
+//#endregion
+//# sourceMappingURL=define-component.d.ts.map

package/dist/core/dist/define-component.js

@@ -0,0 +1,8 @@
+//#region ../core/dist/define-component.js
+function defineComponent(definition) {
+	return definition;
+}
+//#endregion
+export { defineComponent };
+
+//# sourceMappingURL=define-component.js.map

package/dist/core/dist/define-component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-component.js","names":[],"sources":["../../../../core/dist/define-component.js"],"sourcesContent":["export function defineComponent(definition) {\n    return definition;\n}\n//# sourceMappingURL=define-component.js.map"],"mappings":";AAAA,SAAgB,gBAAgB,YAAY;CACxC,OAAO;AACX"}

package/dist/core/dist/define-content-type.d.ts

@@ -0,0 +1,95 @@
+import { JsonValue } from "./schema/generated/schema.js";
+//#region ../core/dist/define-content-type.d.ts
+export type ContentScalarType = 'string' | 'number' | 'integer' | 'boolean';
+export type ContentPropertyType = ContentScalarType | 'array' | 'object';
+/**
+ * The JSON Schema vocabulary subset accepted per scalar property. `widget` carries presentation
+ * annotations (e.g. `{ 'ui:widget': 'media-gallery' }`) passed through to the Schema Registry
+ * uninterpreted. Anything outside this shape is rejected at definition time.
+ */
+export type ContentScalarSchema = {
+  type: ContentScalarType;
+  title?: string;
+  description?: string;
+  /** JSON literal only; executable defaults are forbidden in v1. */
+  default?: string | number | boolean;
+  enum?: readonly (string | number)[];
+  format?: string;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  minimum?: number;
+  maximum?: number;
+  widget?: Record<string, JsonValue>;
+};
+/**
+ * A closed object shape one level below the root. Its properties are scalars only, which is what
+ * bounds nesting at two levels: a third level is not representable rather than merely rejected.
+ */
+export type ContentNestedObjectShape = {
+  type: 'object';
+  additionalProperties: false;
+  required?: readonly string[];
+  properties: Record<string, ContentScalarSchema>;
+};
+export type ContentArraySchema = {
+  type: 'array';
+  title?: string;
+  description?: string;
+  items: ContentNestedObjectShape;
+  minItems?: number;
+  maxItems?: number;
+  widget?: Record<string, JsonValue>;
+};
+export type ContentObjectPropertySchema = ContentNestedObjectShape & {
+  title?: string;
+  description?: string;
+  widget?: Record<string, JsonValue>;
+};
+export type ContentPropertySchema = ContentScalarSchema | ContentArraySchema | ContentObjectPropertySchema;
+/** V1 content models are closed objects. Collections are admitted only at this level. */
+export type ContentObjectSchema = {
+  type: 'object';
+  additionalProperties: false;
+  required?: readonly string[];
+  properties: Record<string, ContentPropertySchema>;
+};
+export type ContentTypeDefinition = {
+  /** Stable, URL-safe id (`^[a-z][a-z0-9-]*$`): becomes the Registry content-type key and the Data Plane path segment. */
+  id: string;
+  /** Human title shown in the Content Platform Admin. */
+  title: string;
+  description?: string;
+  schema: ContentObjectSchema;
+};
+/** Distributes over a naked type parameter so a union of property types maps member-by-member. */
+type PropertyTypeValue<T> = T extends 'string' ? string : T extends 'number' | 'integer' ? number : T extends 'boolean' ? boolean : never;
+type RequiredName<S> = S extends {
+  required: readonly (infer R extends string)[];
+} ? R : never;
+/** Flattens the required/optional intersection into a single object type (preserves modifiers). */
+type Flatten<T> = { [K in keyof T]: T[K]; };
+/** The value of a closed object shape, at the root or one level down. */
+type ObjectValue<S> = S extends {
+  properties: infer P;
+} ? Flatten<{ [K in Extract<keyof P, RequiredName<S>>]: ContentPropertyValue<P[K]>; } & { [K in Exclude<keyof P, RequiredName<S>>]?: ContentPropertyValue<P[K]>; }> : never;
+type ContentPropertyValue<P> = P extends {
+  type: 'array';
+  items: infer I;
+} ? readonly ObjectValue<I>[] : P extends {
+  type: 'object';
+} ? ObjectValue<P> : P extends {
+  enum: readonly (infer E)[];
+} ? E : P extends {
+  type: infer T;
+} ? PropertyTypeValue<T> : never;
+/** JSON-Schema → TS inference for the `$content` prop. Usage: ContentValue<typeof PromotionContent>. */
+export type ContentValue<T extends ContentTypeDefinition> = ObjectValue<T['schema']>;
+/**
+ * Declares a standalone content model. Unlike `defineComponent` (pure identity), this validates at
+ * definition time and throws one aggregated Error listing every violation. The `const` type
+ * parameter preserves literal types so `ContentValue<typeof X>` can infer enums and required keys.
+ */
+export declare function defineContentType<const T extends ContentTypeDefinition>(definition: T): T;
+//#endregion
+//# sourceMappingURL=define-content-type.d.ts.map

package/dist/core/dist/define-content-type.js

@@ -0,0 +1,283 @@
+//#region ../core/dist/define-content-type.js
+const ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+const CONTENT_SCALAR_TYPES = [
+	"string",
+	"number",
+	"integer",
+	"boolean"
+];
+const CONTENT_PROPERTY_TYPES = [
+	...CONTENT_SCALAR_TYPES,
+	"array",
+	"object"
+];
+const SCALAR_TYPE_LIST = "'string' | 'number' | 'integer' | 'boolean'";
+const PROPERTY_TYPE_LIST = `${SCALAR_TYPE_LIST} | 'array' | 'object'`;
+const ROOT_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"additionalProperties",
+	"required",
+	"properties"
+]);
+/** The closed top-level envelope. An unknown key would survive canonicalize + hash and ship to the
+* Registry, so it is rejected here rather than at artifact load. */
+const ENVELOPE_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"title",
+	"description",
+	"schema"
+]);
+const SCALAR_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"title",
+	"description",
+	"default",
+	"enum",
+	"format",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"minimum",
+	"maximum",
+	"widget"
+]);
+const ARRAY_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"title",
+	"description",
+	"items",
+	"minItems",
+	"maxItems",
+	"widget"
+]);
+const OBJECT_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"title",
+	"description",
+	"additionalProperties",
+	"required",
+	"properties",
+	"widget"
+]);
+const STRING_ONLY_KEYWORDS = [
+	"format",
+	"minLength",
+	"maxLength",
+	"pattern"
+];
+const NUMERIC_ONLY_KEYWORDS = ["minimum", "maximum"];
+const STRING_ANNOTATION_KEYWORDS = ["title", "description"];
+const STRING_LENGTH_KEYWORDS = ["minLength", "maxLength"];
+const STRING_PATTERN_KEYWORDS = ["format", "pattern"];
+const ITEM_BOUND_KEYWORDS = ["minItems", "maxItems"];
+/**
+* Declares a standalone content model. Unlike `defineComponent` (pure identity), this validates at
+* definition time and throws one aggregated Error listing every violation. The `const` type
+* parameter preserves literal types so `ContentValue<typeof X>` can infer enums and required keys.
+*/
+function defineContentType(definition) {
+	if (!isRecord(definition)) throw new Error("Invalid content type \"<unknown>\":\n- definition must be an object");
+	const violations = [];
+	collectEnvelopeViolations(definition, violations);
+	collectIdentityViolations(definition, violations);
+	collectSchemaViolations(definition.schema, violations);
+	collectSerializabilityViolations(definition, "definition", [], violations);
+	if (violations.length > 0) {
+		const label = typeof definition.id === "string" && definition.id.length > 0 ? definition.id : "<unknown>";
+		throw new Error(`Invalid content type "${label}":\n- ${violations.join("\n- ")}`);
+	}
+	return definition;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** V6 (envelope): the top-level model shape is closed. */
+function collectEnvelopeViolations(definition, violations) {
+	for (const key of Object.keys(definition)) if (!ENVELOPE_KEYS.has(key)) violations.push(`unknown model key "${key}"`);
+}
+/** V1 (id) and V2 (title). */
+function collectIdentityViolations(definition, violations) {
+	if (typeof definition.id !== "string" || !ID_PATTERN.test(definition.id)) violations.push(`id must be a URL-safe string matching /^[a-z][a-z0-9-]*$/ (got ${JSON.stringify(definition.id)})`);
+	if (typeof definition.title !== "string" || definition.title.length === 0) violations.push("title must be a non-empty string");
+}
+/** V4 (root shape) and V6 (root keyword whitelist), delegating to per-property checks (V5, V6). */
+function collectSchemaViolations(schema, violations) {
+	if (!isRecord(schema)) {
+		violations.push("schema must be an object");
+		return;
+	}
+	collectKeywordViolations("schema", schema, ROOT_KEYWORDS, violations);
+	if (schema.type !== "object") violations.push("schema.type must be 'object'");
+	if (schema.additionalProperties !== false) violations.push("schema.additionalProperties must be false");
+	const { properties, required } = schema;
+	if (!isRecord(properties) || Object.keys(properties).length === 0) violations.push("schema.properties must declare at least one property");
+	else for (const [name, property] of Object.entries(properties)) collectRootPropertyViolations(name, property, violations);
+	collectRequiredViolations("schema", required, properties, violations);
+}
+/** The keyword whitelist for one level, plus the v1 `$ref` prohibition. */
+function collectKeywordViolations(path, value, allowed, violations) {
+	for (const key of Object.keys(value)) if (key === "$ref") violations.push(`${path}: $ref is forbidden in v1`);
+	else if (!allowed.has(key)) violations.push(`${path}: unknown keyword "${key}"`);
+}
+/** `required` names only declared properties, at the root and inside a nested shape. */
+function collectRequiredViolations(path, required, properties, violations) {
+	if (required === void 0) return;
+	if (!Array.isArray(required)) {
+		violations.push(`${path}.required must be an array of property names`);
+		return;
+	}
+	const known = isRecord(properties) ? Object.keys(properties) : [];
+	for (const name of required) if (typeof name !== "string" || !known.includes(name)) violations.push(`${path}.required names unknown property ${JSON.stringify(name)}`);
+}
+/** V5 (vocabulary subset) and V6 (v1 prohibitions) for one root property: six admitted types. */
+function collectRootPropertyViolations(name, property, violations) {
+	const path = `properties.${name}`;
+	if (name === "__proto__") {
+		violations.push(`${path}: property name "${name}" is not allowed`);
+		return;
+	}
+	if (!isRecord(property)) {
+		violations.push(`${path} must be an object`);
+		return;
+	}
+	const type = property.type;
+	collectKeywordViolations(path, property, keywordsFor(type), violations);
+	collectAnnotationViolations(path, property, violations);
+	if (type === "array") {
+		collectArrayViolations(path, property, violations);
+		return;
+	}
+	if (type === "object") {
+		collectObjectShapeViolations(path, property, violations);
+		return;
+	}
+	if (typeof type !== "string" || !CONTENT_PROPERTY_TYPES.includes(type)) {
+		violations.push(`${path}.type must be one of ${PROPERTY_TYPE_LIST} (got ${JSON.stringify(type)})`);
+		return;
+	}
+	collectScalarViolations(path, property, type, violations);
+}
+/** The same rules one level down, where only the four scalar types are admitted. */
+function collectNestedPropertyViolations(path, name, property, violations) {
+	if (name === "__proto__") {
+		violations.push(`${path}: property name "${name}" is not allowed`);
+		return;
+	}
+	if (!isRecord(property)) {
+		violations.push(`${path} must be an object`);
+		return;
+	}
+	const type = property.type;
+	collectKeywordViolations(path, property, SCALAR_KEYWORDS, violations);
+	collectAnnotationViolations(path, property, violations);
+	if (typeof type !== "string" || !CONTENT_SCALAR_TYPES.includes(type)) {
+		violations.push(`${path}.type must be one of ${SCALAR_TYPE_LIST} (got ${JSON.stringify(type)})`);
+		return;
+	}
+	collectScalarViolations(path, property, type, violations);
+}
+function keywordsFor(type) {
+	if (type === "array") return ARRAY_KEYWORDS;
+	if (type === "object") return OBJECT_KEYWORDS;
+	return SCALAR_KEYWORDS;
+}
+function collectAnnotationViolations(path, property, violations) {
+	for (const keyword of STRING_ANNOTATION_KEYWORDS) if (property[keyword] !== void 0 && typeof property[keyword] !== "string") violations.push(`${path}.${keyword} must be a string`);
+	if (property.widget !== void 0 && !isRecord(property.widget)) violations.push(`${path}.widget must be an object`);
+}
+/** An array property: a closed object `items` shape plus the optional item-count bounds. */
+function collectArrayViolations(path, property, violations) {
+	collectItemsViolations(`${path}.items`, property.items, violations);
+	for (const keyword of ITEM_BOUND_KEYWORDS) if (property[keyword] !== void 0 && !isNonNegativeInteger(property[keyword])) violations.push(`${path}.${keyword} must be a non-negative integer`);
+	const { minItems, maxItems } = property;
+	if (isNonNegativeInteger(minItems) && isNonNegativeInteger(maxItems) && minItems > maxItems) violations.push(`${path}.minItems must not exceed maxItems`);
+}
+/** An `items` shape carries the shape envelope only, so its keyword whitelist is the root one. */
+function collectItemsViolations(path, shape, violations) {
+	if (!isRecord(shape)) {
+		violations.push(`${path} must be an object`);
+		return;
+	}
+	collectKeywordViolations(path, shape, ROOT_KEYWORDS, violations);
+	collectObjectShapeViolations(path, shape, violations);
+}
+/**
+* The closed-object body shared by an `items` shape and an `object` property: `type`,
+* `additionalProperties`, a non-empty `properties` map of scalars, and a valid `required`.
+*/
+function collectObjectShapeViolations(path, shape, violations) {
+	if (shape.type !== "object") violations.push(`${path}.type must be 'object'`);
+	if (shape.additionalProperties !== false) violations.push(`${path}.additionalProperties must be false`);
+	const { properties, required } = shape;
+	if (!isRecord(properties) || Object.keys(properties).length === 0) violations.push(`${path}.properties must declare at least one property`);
+	else for (const [name, property] of Object.entries(properties)) collectNestedPropertyViolations(`${path}.properties.${name}`, name, property, violations);
+	collectRequiredViolations(path, required, properties, violations);
+}
+/** The scalar constraint domains, unchanged from v1 and applied at both levels. */
+function collectScalarViolations(path, property, type, violations) {
+	if (type === "string") {
+		for (const keyword of STRING_LENGTH_KEYWORDS) if (property[keyword] !== void 0 && !isNonNegativeInteger(property[keyword])) violations.push(`${path}.${keyword} must be a non-negative integer`);
+		for (const keyword of STRING_PATTERN_KEYWORDS) if (property[keyword] !== void 0 && typeof property[keyword] !== "string") violations.push(`${path}.${keyword} must be a string`);
+		if (typeof property.pattern === "string" && !isValidRegExp(property.pattern)) violations.push(`${path}.pattern must be a valid regular expression`);
+	} else for (const keyword of STRING_ONLY_KEYWORDS) if (property[keyword] !== void 0) violations.push(`${path}.${keyword} only applies to type 'string'`);
+	if (type === "number" || type === "integer") {
+		for (const keyword of NUMERIC_ONLY_KEYWORDS) if (property[keyword] !== void 0 && !isFiniteNumber(property[keyword])) violations.push(`${path}.${keyword} must be a finite number`);
+	} else for (const keyword of NUMERIC_ONLY_KEYWORDS) if (property[keyword] !== void 0) violations.push(`${path}.${keyword} only applies to types 'number' and 'integer'`);
+	if (property.default !== void 0 && !matchesPropertyType(property.default, type)) violations.push(`${path}.default must be a JSON literal of type '${type}'`);
+	if (property.enum !== void 0) {
+		if (type === "boolean") violations.push(`${path}.enum is not allowed on type 'boolean'`);
+		else if (!Array.isArray(property.enum)) violations.push(`${path}.enum must be an array of literals matching type '${type}'`);
+		else if (property.enum.length === 0) violations.push(`${path}.enum must declare at least one member`);
+		else {
+			for (const member of property.enum) if (!matchesPropertyType(member, type)) violations.push(`${path}.enum member ${JSON.stringify(member)} does not match type '${type}'`);
+			if (property.default !== void 0 && !property.enum.includes(property.default)) violations.push(`${path}.default must be one of the enum members`);
+		}
+	}
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isValidRegExp(pattern) {
+	try {
+		new RegExp(pattern);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function matchesPropertyType(value, type) {
+	switch (type) {
+		case "string": return typeof value === "string";
+		case "number": return isFiniteNumber(value);
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+	}
+}
+/** V7 (JSON serializability), applied to the whole definition including `widget` values. */
+function collectSerializabilityViolations(value, path, ancestors, violations) {
+	if (value === null) return;
+	if (typeof value === "function" || typeof value === "undefined" || typeof value === "symbol" || typeof value === "bigint") {
+		violations.push(`${path} is not JSON-serializable (${typeof value})`);
+		return;
+	}
+	if (typeof value !== "object") return;
+	if (ancestors.includes(value)) {
+		violations.push(`${path} is a cyclic reference`);
+		return;
+	}
+	const nextAncestors = [...ancestors, value];
+	if (Array.isArray(value)) {
+		value.forEach((member, index) => {
+			collectSerializabilityViolations(member, `${path}[${index}]`, nextAncestors, violations);
+		});
+		return;
+	}
+	for (const [key, member] of Object.entries(value)) collectSerializabilityViolations(member, `${path}.${key}`, nextAncestors, violations);
+}
+//#endregion
+export { defineContentType };
+
+//# sourceMappingURL=define-content-type.js.map

package/dist/core/dist/define-content-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-content-type.js","names":[],"sources":["../../../../core/dist/define-content-type.js"],"sourcesContent":["const ID_PATTERN = /^[a-z][a-z0-9-]*$/;\nconst CONTENT_SCALAR_TYPES = ['string', 'number', 'integer', 'boolean'];\nconst CONTENT_PROPERTY_TYPES = [...CONTENT_SCALAR_TYPES, 'array', 'object'];\nconst SCALAR_TYPE_LIST = \"'string' | 'number' | 'integer' | 'boolean'\";\nconst PROPERTY_TYPE_LIST = `${SCALAR_TYPE_LIST} | 'array' | 'object'`;\nconst ROOT_KEYWORDS = new Set(['type', 'additionalProperties', 'required', 'properties']);\n/** The closed top-level envelope. An unknown key would survive canonicalize + hash and ship to the\n * Registry, so it is rejected here rather than at artifact load. */\nconst ENVELOPE_KEYS = new Set(['id', 'title', 'description', 'schema']);\nconst SCALAR_KEYWORDS = new Set([\n    'type',\n    'title',\n    'description',\n    'default',\n    'enum',\n    'format',\n    'minLength',\n    'maxLength',\n    'pattern',\n    'minimum',\n    'maximum',\n    'widget',\n]);\nconst ARRAY_KEYWORDS = new Set(['type', 'title', 'description', 'items', 'minItems', 'maxItems', 'widget']);\nconst OBJECT_KEYWORDS = new Set([\n    'type',\n    'title',\n    'description',\n    'additionalProperties',\n    'required',\n    'properties',\n    'widget',\n]);\nconst STRING_ONLY_KEYWORDS = ['format', 'minLength', 'maxLength', 'pattern'];\nconst NUMERIC_ONLY_KEYWORDS = ['minimum', 'maximum'];\nconst STRING_ANNOTATION_KEYWORDS = ['title', 'description'];\nconst STRING_LENGTH_KEYWORDS = ['minLength', 'maxLength'];\nconst STRING_PATTERN_KEYWORDS = ['format', 'pattern'];\nconst ITEM_BOUND_KEYWORDS = ['minItems', 'maxItems'];\n/**\n * Declares a standalone content model. Unlike `defineComponent` (pure identity), this validates at\n * definition time and throws one aggregated Error listing every violation. The `const` type\n * parameter preserves literal types so `ContentValue<typeof X>` can infer enums and required keys.\n */\nexport function defineContentType(definition) {\n    if (!isRecord(definition)) {\n        throw new Error('Invalid content type \"<unknown>\":\\n- definition must be an object');\n    }\n    const violations = [];\n    collectEnvelopeViolations(definition, violations);\n    collectIdentityViolations(definition, violations);\n    collectSchemaViolations(definition.schema, violations);\n    collectSerializabilityViolations(definition, 'definition', [], violations);\n    if (violations.length > 0) {\n        const label = typeof definition.id === 'string' && definition.id.length > 0 ? definition.id : '<unknown>';\n        throw new Error(`Invalid content type \"${label}\":\\n- ${violations.join('\\n- ')}`);\n    }\n    return definition;\n}\nfunction isRecord(value) {\n    return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n/** V6 (envelope): the top-level model shape is closed. */\nfunction collectEnvelopeViolations(definition, violations) {\n    for (const key of Object.keys(definition)) {\n        if (!ENVELOPE_KEYS.has(key)) {\n            violations.push(`unknown model key \"${key}\"`);\n        }\n    }\n}\n/** V1 (id) and V2 (title). */\nfunction collectIdentityViolations(definition, violations) {\n    if (typeof definition.id !== 'string' || !ID_PATTERN.test(definition.id)) {\n        violations.push(`id must be a URL-safe string matching /^[a-z][a-z0-9-]*$/ (got ${JSON.stringify(definition.id)})`);\n    }\n    if (typeof definition.title !== 'string' || definition.title.length === 0) {\n        violations.push('title must be a non-empty string');\n    }\n}\n/** V4 (root shape) and V6 (root keyword whitelist), delegating to per-property checks (V5, V6). */\nfunction collectSchemaViolations(schema, violations) {\n    if (!isRecord(schema)) {\n        violations.push('schema must be an object');\n        return;\n    }\n    collectKeywordViolations('schema', schema, ROOT_KEYWORDS, violations);\n    if (schema.type !== 'object') {\n        violations.push(\"schema.type must be 'object'\");\n    }\n    if (schema.additionalProperties !== false) {\n        violations.push('schema.additionalProperties must be false');\n    }\n    const { properties, required } = schema;\n    if (!isRecord(properties) || Object.keys(properties).length === 0) {\n        violations.push('schema.properties must declare at least one property');\n    }\n    else {\n        for (const [name, property] of Object.entries(properties)) {\n            collectRootPropertyViolations(name, property, violations);\n        }\n    }\n    collectRequiredViolations('schema', required, properties, violations);\n}\n/** The keyword whitelist for one level, plus the v1 `$ref` prohibition. */\nfunction collectKeywordViolations(path, value, allowed, violations) {\n    for (const key of Object.keys(value)) {\n        if (key === '$ref') {\n            violations.push(`${path}: $ref is forbidden in v1`);\n        }\n        else if (!allowed.has(key)) {\n            violations.push(`${path}: unknown keyword \"${key}\"`);\n        }\n    }\n}\n/** `required` names only declared properties, at the root and inside a nested shape. */\nfunction collectRequiredViolations(path, required, properties, violations) {\n    if (required === undefined) {\n        return;\n    }\n    if (!Array.isArray(required)) {\n        violations.push(`${path}.required must be an array of property names`);\n        return;\n    }\n    const known = isRecord(properties) ? Object.keys(properties) : [];\n    for (const name of required) {\n        if (typeof name !== 'string' || !known.includes(name)) {\n            violations.push(`${path}.required names unknown property ${JSON.stringify(name)}`);\n        }\n    }\n}\n/** V5 (vocabulary subset) and V6 (v1 prohibitions) for one root property: six admitted types. */\nfunction collectRootPropertyViolations(name, property, violations) {\n    const path = `properties.${name}`;\n    // In a JS object literal `__proto__:` sets the prototype instead of creating an own property, so the model silently loses the property at runtime.\n    if (name === '__proto__') {\n        violations.push(`${path}: property name \"${name}\" is not allowed`);\n        return;\n    }\n    if (!isRecord(property)) {\n        violations.push(`${path} must be an object`);\n        return;\n    }\n    const type = property.type;\n    collectKeywordViolations(path, property, keywordsFor(type), violations);\n    collectAnnotationViolations(path, property, violations);\n    if (type === 'array') {\n        collectArrayViolations(path, property, violations);\n        return;\n    }\n    if (type === 'object') {\n        collectObjectShapeViolations(path, property, violations);\n        return;\n    }\n    if (typeof type !== 'string' || !CONTENT_PROPERTY_TYPES.includes(type)) {\n        violations.push(`${path}.type must be one of ${PROPERTY_TYPE_LIST} (got ${JSON.stringify(type)})`);\n        return;\n    }\n    collectScalarViolations(path, property, type, violations);\n}\n/** The same rules one level down, where only the four scalar types are admitted. */\nfunction collectNestedPropertyViolations(path, name, property, violations) {\n    if (name === '__proto__') {\n        violations.push(`${path}: property name \"${name}\" is not allowed`);\n        return;\n    }\n    if (!isRecord(property)) {\n        violations.push(`${path} must be an object`);\n        return;\n    }\n    const type = property.type;\n    collectKeywordViolations(path, property, SCALAR_KEYWORDS, violations);\n    collectAnnotationViolations(path, property, violations);\n    if (typeof type !== 'string' || !CONTENT_SCALAR_TYPES.includes(type)) {\n        violations.push(`${path}.type must be one of ${SCALAR_TYPE_LIST} (got ${JSON.stringify(type)})`);\n        return;\n    }\n    collectScalarViolations(path, property, type, violations);\n}\nfunction keywordsFor(type) {\n    if (type === 'array') {\n        return ARRAY_KEYWORDS;\n    }\n    if (type === 'object') {\n        return OBJECT_KEYWORDS;\n    }\n    return SCALAR_KEYWORDS;\n}\nfunction collectAnnotationViolations(path, property, violations) {\n    for (const keyword of STRING_ANNOTATION_KEYWORDS) {\n        if (property[keyword] !== undefined && typeof property[keyword] !== 'string') {\n            violations.push(`${path}.${keyword} must be a string`);\n        }\n    }\n    if (property.widget !== undefined && !isRecord(property.widget)) {\n        violations.push(`${path}.widget must be an object`);\n    }\n}\n/** An array property: a closed object `items` shape plus the optional item-count bounds. */\nfunction collectArrayViolations(path, property, violations) {\n    collectItemsViolations(`${path}.items`, property.items, violations);\n    for (const keyword of ITEM_BOUND_KEYWORDS) {\n        if (property[keyword] !== undefined && !isNonNegativeInteger(property[keyword])) {\n            violations.push(`${path}.${keyword} must be a non-negative integer`);\n        }\n    }\n    const { minItems, maxItems } = property;\n    if (isNonNegativeInteger(minItems) && isNonNegativeInteger(maxItems) && minItems > maxItems) {\n        violations.push(`${path}.minItems must not exceed maxItems`);\n    }\n}\n/** An `items` shape carries the shape envelope only, so its keyword whitelist is the root one. */\nfunction collectItemsViolations(path, shape, violations) {\n    if (!isRecord(shape)) {\n        violations.push(`${path} must be an object`);\n        return;\n    }\n    collectKeywordViolations(path, shape, ROOT_KEYWORDS, violations);\n    collectObjectShapeViolations(path, shape, violations);\n}\n/**\n * The closed-object body shared by an `items` shape and an `object` property: `type`,\n * `additionalProperties`, a non-empty `properties` map of scalars, and a valid `required`.\n */\nfunction collectObjectShapeViolations(path, shape, violations) {\n    if (shape.type !== 'object') {\n        violations.push(`${path}.type must be 'object'`);\n    }\n    if (shape.additionalProperties !== false) {\n        violations.push(`${path}.additionalProperties must be false`);\n    }\n    const { properties, required } = shape;\n    if (!isRecord(properties) || Object.keys(properties).length === 0) {\n        violations.push(`${path}.properties must declare at least one property`);\n    }\n    else {\n        for (const [name, property] of Object.entries(properties)) {\n            collectNestedPropertyViolations(`${path}.properties.${name}`, name, property, violations);\n        }\n    }\n    collectRequiredViolations(path, required, properties, violations);\n}\n/** The scalar constraint domains, unchanged from v1 and applied at both levels. */\nfunction collectScalarViolations(path, property, type, violations) {\n    if (type === 'string') {\n        for (const keyword of STRING_LENGTH_KEYWORDS) {\n            if (property[keyword] !== undefined && !isNonNegativeInteger(property[keyword])) {\n                violations.push(`${path}.${keyword} must be a non-negative integer`);\n            }\n        }\n        for (const keyword of STRING_PATTERN_KEYWORDS) {\n            if (property[keyword] !== undefined && typeof property[keyword] !== 'string') {\n                violations.push(`${path}.${keyword} must be a string`);\n            }\n        }\n        if (typeof property.pattern === 'string' && !isValidRegExp(property.pattern)) {\n            violations.push(`${path}.pattern must be a valid regular expression`);\n        }\n    }\n    else {\n        for (const keyword of STRING_ONLY_KEYWORDS) {\n            if (property[keyword] !== undefined) {\n                violations.push(`${path}.${keyword} only applies to type 'string'`);\n            }\n        }\n    }\n    if (type === 'number' || type === 'integer') {\n        for (const keyword of NUMERIC_ONLY_KEYWORDS) {\n            if (property[keyword] !== undefined && !isFiniteNumber(property[keyword])) {\n                violations.push(`${path}.${keyword} must be a finite number`);\n            }\n        }\n    }\n    else {\n        for (const keyword of NUMERIC_ONLY_KEYWORDS) {\n            if (property[keyword] !== undefined) {\n                violations.push(`${path}.${keyword} only applies to types 'number' and 'integer'`);\n            }\n        }\n    }\n    if (property.default !== undefined && !matchesPropertyType(property.default, type)) {\n        violations.push(`${path}.default must be a JSON literal of type '${type}'`);\n    }\n    if (property.enum !== undefined) {\n        if (type === 'boolean') {\n            violations.push(`${path}.enum is not allowed on type 'boolean'`);\n        }\n        else if (!Array.isArray(property.enum)) {\n            violations.push(`${path}.enum must be an array of literals matching type '${type}'`);\n        }\n        else if (property.enum.length === 0) {\n            violations.push(`${path}.enum must declare at least one member`);\n        }\n        else {\n            for (const member of property.enum) {\n                if (!matchesPropertyType(member, type)) {\n                    violations.push(`${path}.enum member ${JSON.stringify(member)} does not match type '${type}'`);\n                }\n            }\n            if (property.default !== undefined && !property.enum.includes(property.default)) {\n                violations.push(`${path}.default must be one of the enum members`);\n            }\n        }\n    }\n}\nfunction isFiniteNumber(value) {\n    return typeof value === 'number' && Number.isFinite(value);\n}\nfunction isNonNegativeInteger(value) {\n    return typeof value === 'number' && Number.isInteger(value) && value >= 0;\n}\nfunction isValidRegExp(pattern) {\n    try {\n        new RegExp(pattern);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\nfunction matchesPropertyType(value, type) {\n    switch (type) {\n        case 'string':\n            return typeof value === 'string';\n        case 'number':\n            return isFiniteNumber(value);\n        case 'integer':\n            return typeof value === 'number' && Number.isInteger(value);\n        case 'boolean':\n            return typeof value === 'boolean';\n    }\n}\n/** V7 (JSON serializability), applied to the whole definition including `widget` values. */\nfunction collectSerializabilityViolations(value, path, ancestors, violations) {\n    if (value === null) {\n        return;\n    }\n    if (typeof value === 'function' ||\n        typeof value === 'undefined' ||\n        typeof value === 'symbol' ||\n        typeof value === 'bigint') {\n        violations.push(`${path} is not JSON-serializable (${typeof value})`);\n        return;\n    }\n    if (typeof value !== 'object') {\n        return;\n    }\n    if (ancestors.includes(value)) {\n        violations.push(`${path} is a cyclic reference`);\n        return;\n    }\n    const nextAncestors = [...ancestors, value];\n    if (Array.isArray(value)) {\n        value.forEach((member, index) => {\n            collectSerializabilityViolations(member, `${path}[${index}]`, nextAncestors, violations);\n        });\n        return;\n    }\n    for (const [key, member] of Object.entries(value)) {\n        collectSerializabilityViolations(member, `${path}.${key}`, nextAncestors, violations);\n    }\n}\n//# sourceMappingURL=define-content-type.js.map"],"mappings":"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"}

package/dist/core/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ActionSelector } from "./actions/registry.js";
+import { MockActions, mockAction } from "./actions/mock-action.js";
+import { Direction, JsonValue, StorefrontContext } from "./schema/generated/schema.js";
+import { ContentArraySchema, ContentNestedObjectShape, ContentObjectPropertySchema, ContentObjectSchema, ContentPropertySchema, ContentPropertyType, ContentScalarSchema, ContentScalarType, ContentTypeDefinition, ContentValue, defineContentType } from "./define-content-type.js";
+import { ComponentDefinition, EditorMetadata, FetchStrategy, PropSchema, PropSchemaField, PropType, defineComponent } from "./define-component.js";
+import "./types.js";
+export { type ActionSelector, type ComponentDefinition, type ContentArraySchema, type ContentNestedObjectShape, type ContentObjectPropertySchema, type ContentObjectSchema, type ContentPropertySchema, type ContentPropertyType, type ContentScalarSchema, type ContentScalarType, type ContentTypeDefinition, type ContentValue, type EditorMetadata, type FetchStrategy, type JsonValue, type MockActions, type PropSchema, type PropSchemaField, type PropType, type StorefrontContext, defineComponent, defineContentType, mockAction };