@fmaplabs/meta-manifest 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1229 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_API_VERSION: () => DEFAULT_API_VERSION,
+  Field: () => Field,
+  SyncTransportError: () => SyncTransportError,
+  defineConfig: () => defineConfig,
+  defineMetaobject: () => defineMetaobject,
+  diff: () => diff,
+  generateSchemaSource: () => generateSchemaSource,
+  m: () => m,
+  normalizeLocal: () => normalizeLocal,
+  normalizeRemote: () => normalizeRemote,
+  pull: () => pull,
+  pullAll: () => pullAll,
+  push: () => push,
+  toDefinitionInput: () => toDefinitionInput,
+  validateConfig: () => validateConfig
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var DEFAULT_API_VERSION = "2026-07";
+function defineConfig(config) {
+  return config;
+}
+function validateConfig(raw) {
+  const c = raw;
+  for (const key of ["shop", "accessToken", "schema"]) {
+    if (!c || typeof c[key] !== "string" || c[key] === "") {
+      throw new Error(`Invalid config: missing or empty "${key}".`);
+    }
+  }
+  return c;
+}
+
+// src/fields/base.ts
+var Field = class {
+  /** True when Shopify stores this type as a JSON string (objects, lists). */
+  wireIsJson = false;
+  required = false;
+  name;
+  description;
+  /** Constraint validation on an already-typed value. */
+  check(_value) {
+    return [];
+  }
+  /** Shopify wire (string or jsonValue) -> typed value (no constraint checking). */
+  coerce(wire) {
+    let json2 = wire;
+    if (this.wireIsJson && typeof wire === "string") {
+      try {
+        json2 = JSON.parse(wire);
+      } catch {
+        return { issues: [{ message: "Invalid JSON in field value" }] };
+      }
+    }
+    return this.fromJson(json2);
+  }
+  /** Shopify wire -> typed value, validated. */
+  decode(wire) {
+    const coerced = this.coerce(wire);
+    if (coerced.issues) return coerced;
+    const issues = this.check(coerced.value);
+    return issues.length ? { issues } : { value: coerced.value };
+  }
+  /** Typed value -> Shopify wire string. */
+  encode(value) {
+    const json2 = this.toJson(value);
+    return this.wireIsJson ? JSON.stringify(json2) : String(json2);
+  }
+  /** Element-level JSON form (for embedding inside list values). */
+  elementToJson(value) {
+    return this.toJson(value);
+  }
+  /** Element-level decode from a JSON form (coerce + check), for list elements. */
+  elementFromJson(json2) {
+    const coerced = this.fromJson(json2);
+    if (coerced.issues) return coerced;
+    const issues = this.check(coerced.value);
+    return issues.length ? { issues } : { value: coerced.value };
+  }
+  get ["~standard"]() {
+    return {
+      version: 1,
+      vendor: "@fmaplabs/meta-manifest",
+      validate: (value) => {
+        const issues = this.check(value);
+        return issues.length ? { issues } : { value };
+      }
+    };
+  }
+};
+
+// src/fields/boolean.ts
+var BooleanField = class extends Field {
+  shopifyType = "boolean";
+  constructor(opts) {
+    super();
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  validations() {
+    return [];
+  }
+  toJson(value) {
+    return value;
+  }
+  fromJson(json2) {
+    if (typeof json2 === "boolean") return { value: json2 };
+    if (json2 === "true") return { value: true };
+    if (json2 === "false") return { value: false };
+    return { issues: [{ message: `Expected a boolean, got ${json2}` }] };
+  }
+};
+function boolean(opts = {}) {
+  return new BooleanField(opts);
+}
+
+// src/fields/list.ts
+var ListField = class extends Field {
+  constructor(inner, o) {
+    super();
+    this.inner = inner;
+    this.o = o;
+    this.shopifyType = `list.${inner.shopifyType}`;
+    this.required = o.required ?? false;
+    this.name = o.name;
+    this.description = o.description;
+  }
+  inner;
+  o;
+  shopifyType;
+  wireIsJson = true;
+  validations() {
+    const v2 = [...this.inner.validations()];
+    if (this.o.min != null) v2.push({ name: "list.min", value: String(this.o.min) });
+    if (this.o.max != null) v2.push({ name: "list.max", value: String(this.o.max) });
+    return v2;
+  }
+  toJson(value) {
+    return value.map((el) => this.inner.elementToJson(el));
+  }
+  fromJson(json2) {
+    if (!Array.isArray(json2)) return { issues: [{ message: "Expected an array" }] };
+    const out = [];
+    const issues = [];
+    json2.forEach((el, index) => {
+      const r = this.inner.elementFromJson(el);
+      if (r.issues) issues.push(...r.issues.map((i) => ({ ...i, path: [index, ...i.path ?? []] })));
+      else out.push(r.value);
+    });
+    return issues.length ? { issues } : { value: out };
+  }
+};
+function list(inner, opts = {}) {
+  return new ListField(inner, opts);
+}
+
+// src/fields/measurement.ts
+var MeasurementField = class extends Field {
+  constructor(opts, shopifyType) {
+    super();
+    this.shopifyType = shopifyType;
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  shopifyType;
+  wireIsJson = true;
+  validations() {
+    return [];
+  }
+  toJson(value) {
+    return { value: value.value, unit: value.unit };
+  }
+  fromJson(json2) {
+    if (typeof json2 !== "object" || json2 === null) return { issues: [{ message: "Expected a measurement object" }] };
+    const o = json2;
+    const value = typeof o.value === "string" ? Number(o.value) : o.value;
+    if (typeof value !== "number" || Number.isNaN(value) || typeof o.unit !== "string") {
+      return { issues: [{ message: "measurement requires numeric value and string unit" }] };
+    }
+    return { value: { value, unit: o.unit } };
+  }
+};
+function dimension(opts = {}) {
+  return new MeasurementField(opts, "dimension");
+}
+function weight(opts = {}) {
+  return new MeasurementField(opts, "weight");
+}
+function volume(opts = {}) {
+  return new MeasurementField(opts, "volume");
+}
+
+// src/fields/money.ts
+var MoneyField = class extends Field {
+  shopifyType = "money";
+  wireIsJson = true;
+  constructor(opts) {
+    super();
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  validations() {
+    return [];
+  }
+  toJson(value) {
+    return { amount: value.amount, currency_code: value.currencyCode };
+  }
+  fromJson(json2) {
+    if (typeof json2 !== "object" || json2 === null) return { issues: [{ message: "Expected a money object" }] };
+    const o = json2;
+    if (typeof o.amount !== "string" || typeof o.currency_code !== "string") {
+      return { issues: [{ message: "money requires string amount and currency_code" }] };
+    }
+    return { value: { amount: o.amount, currencyCode: o.currency_code } };
+  }
+};
+function money(opts = {}) {
+  return new MoneyField(opts);
+}
+
+// src/fields/number.ts
+var NumericField = class extends Field {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  opts;
+  toJson(value) {
+    return value;
+  }
+  fromJson(json2) {
+    const n = typeof json2 === "string" ? Number(json2) : json2;
+    if (typeof n !== "number" || Number.isNaN(n)) return { issues: [{ message: `Expected a number, got ${json2}` }] };
+    return { value: n };
+  }
+  rangeIssues(value) {
+    const i = [];
+    if (this.opts.min != null && value < this.opts.min) i.push({ message: `Must be at least ${this.opts.min}` });
+    if (this.opts.max != null && value > this.opts.max) i.push({ message: `Must be at most ${this.opts.max}` });
+    return i;
+  }
+  baseValidations() {
+    const v2 = [];
+    if (this.opts.min != null) v2.push({ name: "min", value: String(this.opts.min) });
+    if (this.opts.max != null) v2.push({ name: "max", value: String(this.opts.max) });
+    return v2;
+  }
+};
+var IntegerField = class extends NumericField {
+  shopifyType = "number_integer";
+  validations() {
+    return this.baseValidations();
+  }
+  check(value) {
+    const i = this.rangeIssues(value);
+    if (!Number.isInteger(value)) i.unshift({ message: "Must be an integer" });
+    return i;
+  }
+};
+var DecimalField = class extends NumericField {
+  constructor(decimalOpts) {
+    super(decimalOpts);
+    this.decimalOpts = decimalOpts;
+  }
+  decimalOpts;
+  shopifyType = "number_decimal";
+  validations() {
+    const v2 = this.baseValidations();
+    if (this.decimalOpts.maxPrecision != null) {
+      v2.push({ name: "max_precision", value: String(this.decimalOpts.maxPrecision) });
+    }
+    return v2;
+  }
+  check(value) {
+    return this.rangeIssues(value);
+  }
+};
+function integer(opts = {}) {
+  return new IntegerField(opts);
+}
+function decimal(opts = {}) {
+  return new DecimalField(opts);
+}
+
+// src/fields/rating.ts
+var RatingField = class extends Field {
+  constructor(o) {
+    super();
+    this.o = o;
+    this.required = o.required ?? false;
+    this.name = o.name;
+    this.description = o.description;
+  }
+  o;
+  shopifyType = "rating";
+  wireIsJson = true;
+  validations() {
+    return [
+      { name: "min", value: String(this.o.min) },
+      { name: "max", value: String(this.o.max) }
+    ];
+  }
+  toJson(value) {
+    return { value: String(value.value), scale_min: String(this.o.min), scale_max: String(this.o.max) };
+  }
+  fromJson(json2) {
+    if (typeof json2 !== "object" || json2 === null) return { issues: [{ message: "Expected a rating object" }] };
+    const o = json2;
+    const value = Number(o.value);
+    const scaleMin = Number(o.scale_min);
+    const scaleMax = Number(o.scale_max);
+    if ([value, scaleMin, scaleMax].some(Number.isNaN)) {
+      return { issues: [{ message: "rating requires numeric value, scale_min, scale_max" }] };
+    }
+    return { value: { value, scaleMin, scaleMax } };
+  }
+  check(value) {
+    return value.value < value.scaleMin || value.value > value.scaleMax ? [{ message: `Rating must be between ${value.scaleMin} and ${value.scaleMax}` }] : [];
+  }
+  get ["~standard"]() {
+    return {
+      version: 1,
+      vendor: "@fmaplabs/meta-manifest",
+      validate: (input) => {
+        if (typeof input !== "object" || input === null || typeof input.value !== "number") {
+          return { issues: [{ message: "Expected a rating input { value: number }" }] };
+        }
+        const candidate = {
+          value: input.value,
+          scaleMin: this.o.min,
+          scaleMax: this.o.max
+        };
+        const issues = this.check(candidate);
+        return issues.length ? { issues } : { value: candidate };
+      }
+    };
+  }
+};
+function rating(opts) {
+  return new RatingField(opts);
+}
+
+// src/fields/reference.ts
+var GidField = class extends Field {
+  constructor(opts) {
+    super();
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  toJson(value) {
+    return value;
+  }
+  fromJson(json2) {
+    if (typeof json2 !== "string") return { issues: [{ message: `Expected a GID string, got ${typeof json2}` }] };
+    return { value: json2 };
+  }
+};
+var SimpleRefField = class extends GidField {
+  constructor(opts, shopifyType) {
+    super(opts);
+    this.shopifyType = shopifyType;
+  }
+  shopifyType;
+  validations() {
+    return [];
+  }
+};
+var FileField = class extends GidField {
+  constructor(o) {
+    super(o);
+    this.o = o;
+  }
+  o;
+  shopifyType = "file_reference";
+  validations() {
+    return this.o.accept != null ? [{ name: "file_type_options", value: JSON.stringify(this.o.accept) }] : [];
+  }
+};
+function resolveType(target) {
+  return typeof target === "function" ? target().type : target.type;
+}
+var MetaobjectRefField = class extends GidField {
+  constructor(target, opts) {
+    super(opts);
+    this.target = target;
+  }
+  target;
+  shopifyType = "metaobject_reference";
+  validations() {
+    return [{ name: "metaobject_definition_type", value: resolveType(this.target) }];
+  }
+};
+function product(opts = {}) {
+  return new SimpleRefField(opts, "product_reference");
+}
+function variant(opts = {}) {
+  return new SimpleRefField(opts, "variant_reference");
+}
+function collection(opts = {}) {
+  return new SimpleRefField(opts, "collection_reference");
+}
+function page(opts = {}) {
+  return new SimpleRefField(opts, "page_reference");
+}
+function file(opts = {}) {
+  return new FileField(opts);
+}
+function ref(target, opts = {}) {
+  return new MetaobjectRefField(target, opts);
+}
+
+// src/fields/scalar.ts
+var StringScalarField = class extends Field {
+  constructor(opts) {
+    super();
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  toJson(value) {
+    return value;
+  }
+  fromJson(json2) {
+    if (typeof json2 !== "string") return { issues: [{ message: `Expected string, got ${typeof json2}` }] };
+    return { value: json2 };
+  }
+};
+var DateField = class extends StringScalarField {
+  constructor(o, shopifyType) {
+    super(o);
+    this.o = o;
+    this.shopifyType = shopifyType;
+  }
+  o;
+  shopifyType;
+  validations() {
+    const v2 = [];
+    if (this.o.min != null) v2.push({ name: "min", value: this.o.min });
+    if (this.o.max != null) v2.push({ name: "max", value: this.o.max });
+    return v2;
+  }
+};
+var UrlField = class extends StringScalarField {
+  constructor(o) {
+    super(o);
+    this.o = o;
+  }
+  o;
+  shopifyType = "url";
+  validations() {
+    return this.o.allowedDomains != null ? [{ name: "allowed_domains", value: JSON.stringify(this.o.allowedDomains) }] : [];
+  }
+};
+var ColorField = class extends StringScalarField {
+  shopifyType = "color";
+  validations() {
+    return [];
+  }
+  check(value) {
+    return /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value) ? [] : [{ message: "Must be a hex color like #ff0000" }];
+  }
+};
+var JsonField = class extends Field {
+  shopifyType = "json";
+  wireIsJson = true;
+  constructor(opts) {
+    super();
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  validations() {
+    return [];
+  }
+  toJson(value) {
+    return value;
+  }
+  fromJson(json2) {
+    return { value: json2 };
+  }
+};
+function date(opts = {}) {
+  return new DateField(opts, "date");
+}
+function dateTime(opts = {}) {
+  return new DateField(opts, "date_time");
+}
+function url(opts = {}) {
+  return new UrlField(opts);
+}
+function color(opts = {}) {
+  return new ColorField(opts);
+}
+function json(opts = {}) {
+  return new JsonField(opts);
+}
+
+// src/fields/text.ts
+var TextField = class extends Field {
+  constructor(opts, multiline) {
+    super();
+    this.opts = opts;
+    this.shopifyType = multiline ? "multi_line_text_field" : "single_line_text_field";
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+  }
+  opts;
+  shopifyType;
+  validations() {
+    const v2 = [];
+    if (this.opts.min != null) v2.push({ name: "min", value: String(this.opts.min) });
+    if (this.opts.max != null) v2.push({ name: "max", value: String(this.opts.max) });
+    if (this.opts.regex != null) v2.push({ name: "regex", value: this.opts.regex });
+    if (this.opts.choices != null) v2.push({ name: "choices", value: JSON.stringify(this.opts.choices) });
+    return v2;
+  }
+  toJson(value) {
+    return value;
+  }
+  fromJson(json2) {
+    if (typeof json2 !== "string") return { issues: [{ message: `Expected string, got ${typeof json2}` }] };
+    return { value: json2 };
+  }
+  check(value) {
+    const i = [];
+    const { min, max, regex, choices } = this.opts;
+    if (min != null && value.length < min) i.push({ message: `Must be at least ${min} characters` });
+    if (max != null && value.length > max) i.push({ message: `Must be at most ${max} characters` });
+    if (regex != null && !new RegExp(regex).test(value)) i.push({ message: `Must match ${regex}` });
+    if (choices != null && !choices.includes(value)) i.push({ message: `Must be one of: ${choices.join(", ")}` });
+    return i;
+  }
+};
+function text(opts = {}) {
+  return new TextField(opts, false);
+}
+function multilineText(opts = {}) {
+  return new TextField(opts, true);
+}
+
+// src/fields/index.ts
+var m = {
+  text,
+  multilineText,
+  integer,
+  decimal,
+  boolean,
+  date,
+  dateTime,
+  url,
+  color,
+  json,
+  money,
+  dimension,
+  weight,
+  volume,
+  rating,
+  product,
+  variant,
+  collection,
+  page,
+  file,
+  ref,
+  list
+};
+
+// src/definition-input.ts
+function mapAccess(access) {
+  if (!access) return void 0;
+  const out = {};
+  if (access.admin) out.admin = access.admin.toUpperCase();
+  if (access.storefront) out.storefront = access.storefront.toUpperCase();
+  return out;
+}
+function mapCapabilities(caps) {
+  if (!caps) return void 0;
+  const out = {};
+  for (const [k, v2] of Object.entries(caps)) if (v2 != null) out[k] = { enabled: v2 };
+  return Object.keys(out).length ? out : void 0;
+}
+function toDefinitionInput(schema) {
+  const { config } = schema;
+  const fieldDefinitions = Object.entries(schema.fields).map(([key, field]) => {
+    const def = {
+      key,
+      name: field.name ?? key,
+      required: field.required,
+      type: field.shopifyType,
+      validations: field.validations()
+    };
+    if (field.description != null) def.description = field.description;
+    return def;
+  });
+  const out = {
+    type: schema.type,
+    name: config.name,
+    fieldDefinitions
+  };
+  if (config.description != null) out.description = config.description;
+  if (config.displayName != null) out.displayNameKey = config.displayName;
+  const access = mapAccess(config.access);
+  if (access) out.access = access;
+  const capabilities = mapCapabilities(config.capabilities);
+  if (capabilities) out.capabilities = capabilities;
+  return out;
+}
+
+// src/define.ts
+function toValueMap(input) {
+  const map = /* @__PURE__ */ new Map();
+  if (Array.isArray(input)) {
+    for (const f of input) map.set(f.key, "jsonValue" in f && f.jsonValue !== void 0 ? f.jsonValue : f.value);
+  } else {
+    for (const [k, v2] of Object.entries(input)) map.set(k, v2);
+  }
+  return map;
+}
+function defineMetaobject(handle, config) {
+  const type = `$app:${handle}`;
+  const entries = Object.entries(config.fields);
+  function parse(input) {
+    const values = toValueMap(input);
+    const out = {};
+    const issues = [];
+    for (const [key, field] of entries) {
+      if (!values.has(key) || values.get(key) === void 0 || values.get(key) === null) {
+        if (field.required) issues.push({ message: `Missing required field "${key}"`, path: [key] });
+        continue;
+      }
+      const r = field.decode(values.get(key));
+      if (r.issues) issues.push(...r.issues.map((i) => ({ ...i, path: [key, ...i.path ?? []] })));
+      else out[key] = r.value;
+    }
+    return issues.length ? { issues } : { value: out };
+  }
+  function encode(value) {
+    const result = [];
+    for (const [key, field] of entries) {
+      const v2 = value[key];
+      if (v2 === void 0) continue;
+      result.push({ key, value: field.encode(v2) });
+    }
+    return result;
+  }
+  const schemaRef = {
+    handle,
+    type,
+    config,
+    fields: config.fields,
+    parse,
+    encode,
+    toDefinitionInput: () => toDefinitionInput(schemaRef),
+    ["~standard"]: {
+      version: 1,
+      vendor: "@fmaplabs/meta-manifest",
+      validate: (input) => parse(input)
+    }
+  };
+  return schemaRef;
+}
+
+// src/codegen.ts
+var APP_PREFIX = "$app:";
+var SIMPLE = {
+  single_line_text_field: "text",
+  multi_line_text_field: "multilineText",
+  number_integer: "integer",
+  number_decimal: "decimal",
+  boolean: "boolean",
+  date: "date",
+  date_time: "dateTime",
+  url: "url",
+  color: "color",
+  json: "json",
+  money: "money",
+  dimension: "dimension",
+  weight: "weight",
+  volume: "volume",
+  product_reference: "product",
+  variant_reference: "variant",
+  collection_reference: "collection",
+  page_reference: "page",
+  file_reference: "file"
+};
+function handleOf(type) {
+  return type.startsWith(APP_PREFIX) ? type.slice(APP_PREFIX.length) : type;
+}
+function identOf(type) {
+  return handleOf(type).split(/[^a-zA-Z0-9]+/).filter(Boolean).map((p) => p[0].toUpperCase() + p.slice(1)).join("");
+}
+function v(validations, name) {
+  return validations.find((x) => x.name === name)?.value;
+}
+function refTarget(field) {
+  const single = v(field.validations, "metaobject_definition_type");
+  if (single) return single;
+  const many = v(field.validations, "metaobject_definition_types");
+  if (many) {
+    try {
+      const arr = JSON.parse(many);
+      if (Array.isArray(arr) && arr.length) return String(arr[0]);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function optsLiteral(entries) {
+  return entries.length ? `{ ${entries.join(", ")} }` : "";
+}
+function scalarEntries(field, warnings, builder) {
+  const e = [];
+  if (field.required) e.push("required: true");
+  const num = (name, opt) => {
+    const val = v(field.validations, name);
+    if (val !== void 0) e.push(`${opt}: ${Number(val)}`);
+  };
+  const str = (name, opt) => {
+    const val = v(field.validations, name);
+    if (val !== void 0) e.push(`${opt}: ${JSON.stringify(val)}`);
+  };
+  const jsonArr = (name, opt) => {
+    const val = v(field.validations, name);
+    if (val !== void 0) {
+      try {
+        e.push(`${opt}: ${JSON.stringify(JSON.parse(val))}`);
+      } catch {
+        warnings.push(`could not parse "${name}" on field "${field.key}"`);
+      }
+    }
+  };
+  if (builder === "date" || builder === "dateTime") {
+    str("min", "min");
+    str("max", "max");
+  } else {
+    num("min", "min");
+    num("max", "max");
+  }
+  str("regex", "regex");
+  jsonArr("choices", "choices");
+  num("max_precision", "maxPrecision");
+  jsonArr("allowed_domains", "allowedDomains");
+  jsonArr("file_type_options", "accept");
+  return e;
+}
+function scalarCall(builder, field, warnings) {
+  const lit = optsLiteral(scalarEntries(field, warnings, builder));
+  return lit ? `m.${builder}(${lit})` : `m.${builder}()`;
+}
+function fieldCall(field, typeToIdent, warnings) {
+  const type = field.type;
+  if (type === "rating") {
+    const min = v(field.validations, "min");
+    const max = v(field.validations, "max");
+    const e = [`min: ${Number(min ?? 1)}`, `max: ${Number(max ?? 5)}`];
+    if (field.required) e.unshift("required: true");
+    if (min === void 0 || max === void 0) warnings.push(`rating field "${field.key}" missing min/max`);
+    return `m.rating(${optsLiteral(e)})`;
+  }
+  if (type === "metaobject_reference") {
+    const target = refTarget(field);
+    const ident = target ? typeToIdent.get(target) : void 0;
+    if (!ident) {
+      warnings.push(`unresolved reference on field "${field.key}"`);
+      return `m.json() /* TODO: unmapped reference */`;
+    }
+    return field.required ? `m.ref(() => ${ident}, { required: true })` : `m.ref(() => ${ident})`;
+  }
+  if (type.startsWith("list.")) {
+    const inner = type.slice("list.".length);
+    const listEntries = [];
+    if (field.required) listEntries.push("required: true");
+    const min = v(field.validations, "list.min");
+    const max = v(field.validations, "list.max");
+    if (min !== void 0) listEntries.push(`min: ${Number(min)}`);
+    if (max !== void 0) listEntries.push(`max: ${Number(max)}`);
+    const listOpts = optsLiteral(listEntries);
+    let innerCall;
+    if (inner === "metaobject_reference") {
+      const target = refTarget(field);
+      const ident = target ? typeToIdent.get(target) : void 0;
+      if (!ident) {
+        warnings.push(`unresolved list reference on field "${field.key}"`);
+        return `m.json() /* TODO: unmapped list reference */`;
+      }
+      innerCall = `m.ref(() => ${ident})`;
+    } else if (SIMPLE[inner]) {
+      innerCall = scalarCall(SIMPLE[inner], { ...field, required: false }, warnings);
+    } else {
+      warnings.push(`unmapped list element type "${inner}" on field "${field.key}"`);
+      return `m.json() /* TODO: unmapped list element ${inner} */`;
+    }
+    return listOpts ? `m.list(${innerCall}, ${listOpts})` : `m.list(${innerCall})`;
+  }
+  if (SIMPLE[type]) return scalarCall(SIMPLE[type], field, warnings);
+  warnings.push(`unmapped field type "${type}" on field "${field.key}"`);
+  return `m.json() /* TODO: unmapped type ${type} */`;
+}
+function defSource(def, typeToIdent, warnings) {
+  const ident = typeToIdent.get(def.type);
+  const handle = handleOf(def.type);
+  const fields = def.fields.map((f) => `    ${f.key}: ${fieldCall(f, typeToIdent, warnings)},`).join("\n");
+  const name = def.name ? `
+  name: ${JSON.stringify(def.name)},` : "";
+  return `export const ${ident} = defineMetaobject(${JSON.stringify(handle)}, {${name}
+  fields: {
+${fields}
+  },
+});`;
+}
+function referencedTypes(def) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of def.fields) {
+    if (f.type === "metaobject_reference" || f.type === "list.metaobject_reference") {
+      const t = refTarget(f);
+      if (t) out.add(t);
+    }
+  }
+  return out;
+}
+function orderDefs(defs) {
+  const byType = new Map(defs.map((d) => [d.type, d]));
+  const deps = new Map(defs.map((d) => [d.type, referencedTypes(d)]));
+  const ordered = [];
+  const placed = /* @__PURE__ */ new Set();
+  let progress = true;
+  while (ordered.length < defs.length && progress) {
+    progress = false;
+    for (const d of defs) {
+      if (placed.has(d.type)) continue;
+      const unmet = [...deps.get(d.type) ?? []].filter((t) => byType.has(t) && !placed.has(t) && t !== d.type);
+      if (unmet.length === 0) {
+        ordered.push(d);
+        placed.add(d.type);
+        progress = true;
+      }
+    }
+  }
+  for (const d of defs) if (!placed.has(d.type)) ordered.push(d);
+  return ordered;
+}
+function generateSchemaSource(defs) {
+  const ordered = orderDefs(defs);
+  const typeToIdent = new Map(ordered.map((d) => [d.type, identOf(d.type)]));
+  const warnings = [];
+  const blocks = ordered.map((d) => defSource(d, typeToIdent, warnings));
+  const idents = ordered.map((d) => typeToIdent.get(d.type));
+  const header = `import { defineMetaobject, m } from "@fmaplabs/meta-manifest";`;
+  const body = blocks.join("\n\n");
+  const footer = `export const schemas = [${idents.join(", ")}];`;
+  for (const w of warnings) console.warn(`[meta-manifest] codegen: ${w}`);
+  return `${header}
+
+${body}
+
+${footer}
+`;
+}
+
+// src/sync/diff.ts
+function sameValidations(a, b) {
+  const norm = (v2) => JSON.stringify([...v2].sort((x, y) => x.name.localeCompare(y.name)));
+  return norm(a) === norm(b);
+}
+function diff(local, remote) {
+  const ops = [];
+  const remoteByType = new Map(remote.map((d) => [d.type, d]));
+  for (const localDef of local) {
+    const remoteDef = remoteByType.get(localDef.type);
+    if (!remoteDef) {
+      ops.push({ kind: "createDefinition", type: localDef.type, definition: localDef });
+      continue;
+    }
+    const remoteFields = new Map(remoteDef.fields.map((f) => [f.key, f]));
+    const localKeys = new Set(localDef.fields.map((f) => f.key));
+    for (const lf of localDef.fields) {
+      const rf = remoteFields.get(lf.key);
+      if (!rf) {
+        ops.push({ kind: "addField", type: localDef.type, field: lf });
+        continue;
+      }
+      if (rf.type !== lf.type) {
+        ops.push({ kind: "changeFieldType", type: localDef.type, key: lf.key, from: rf.type, to: lf.type, destructive: true });
+        continue;
+      }
+      const changes = {};
+      if (rf.required !== lf.required) changes.required = lf.required;
+      if (!sameValidations(rf.validations, lf.validations)) changes.validations = lf.validations;
+      if (Object.keys(changes).length) {
+        ops.push({ kind: "updateField", type: localDef.type, key: lf.key, changes });
+      }
+    }
+    for (const rf of remoteDef.fields) {
+      if (!localKeys.has(rf.key)) {
+        ops.push({ kind: "removeField", type: localDef.type, key: rf.key, destructive: true });
+      }
+    }
+  }
+  return ops;
+}
+
+// src/sync/normalize.ts
+function normalizeLocal(schema) {
+  const def = schema.toDefinitionInput();
+  return {
+    type: def.type,
+    name: def.name,
+    fields: def.fieldDefinitions.map((f) => ({
+      key: f.key,
+      type: f.type,
+      required: f.required,
+      validations: f.validations
+    }))
+  };
+}
+function normalizeRemote(def) {
+  return {
+    type: def.type,
+    name: def.name,
+    fields: def.fieldDefinitions.map((f) => ({
+      key: f.key,
+      type: typeof f.type === "string" ? f.type : f.type.name,
+      required: f.required,
+      validations: f.validations ?? []
+    }))
+  };
+}
+
+// src/sync/client.ts
+var PULL_DEFINITION_QUERY = `query PullMetaobjectDefinition($type: String!) {
+  metaobjectDefinitionByType(type: $type) {
+    id
+    name
+    type
+    description
+    displayNameKey
+    fieldDefinitions {
+      key
+      name
+      description
+      required
+      type { name }
+      validations { name value }
+    }
+    access { admin storefront }
+    capabilities {
+      publishable { enabled }
+      translatable { enabled }
+      renderable { enabled }
+    }
+  }
+}`;
+var LIST_DEFINITIONS_QUERY = `query ListMetaobjectDefinitions($after: String) {
+  metaobjectDefinitions(first: 50, after: $after) {
+    nodes {
+      id
+      name
+      type
+      fieldDefinitions {
+        key
+        name
+        description
+        required
+        type { name }
+        validations { name value }
+      }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`;
+var CREATE_DEFINITION_MUTATION = `mutation CreateMetaobjectDefinition($definition: MetaobjectDefinitionCreateInput!) {
+  metaobjectDefinitionCreate(definition: $definition) {
+    metaobjectDefinition { id type }
+    userErrors { field message code }
+  }
+}`;
+var UPDATE_DEFINITION_MUTATION = `mutation UpdateMetaobjectDefinition($id: ID!, $definition: MetaobjectDefinitionUpdateInput!) {
+  metaobjectDefinitionUpdate(id: $id, definition: $definition) {
+    metaobjectDefinition { id type }
+    userErrors { field message code }
+  }
+}`;
+var SyncTransportError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "SyncTransportError";
+  }
+  errors;
+};
+async function execute(client, query, variables) {
+  const result = await client(query, variables ? { variables } : void 0);
+  if (Array.isArray(result.errors) ? result.errors.length > 0 : result.errors != null) {
+    throw new SyncTransportError("GraphQL request failed", result.errors);
+  }
+  return result.data;
+}
+
+// src/sync/pull.ts
+async function pull(client, types) {
+  const out = [];
+  for (const type of types) {
+    const data = await execute(client, PULL_DEFINITION_QUERY, { type });
+    const node = data.metaobjectDefinitionByType;
+    if (!node) continue;
+    out.push({
+      id: node.id,
+      type,
+      definition: { type, name: node.name, fieldDefinitions: node.fieldDefinitions }
+    });
+  }
+  return out;
+}
+function toCanonicalType(resolved) {
+  const m2 = /^app--\d+--(.+)$/.exec(resolved);
+  return m2 ? `$app:${m2[1]}` : null;
+}
+async function pullAll(client, opts = {}) {
+  const appOwnedOnly = opts.appOwnedOnly ?? true;
+  const out = [];
+  let after = null;
+  do {
+    const data = await execute(client, LIST_DEFINITIONS_QUERY, { after });
+    for (const node of data.metaobjectDefinitions.nodes) {
+      const canonical = toCanonicalType(node.type);
+      if (appOwnedOnly && !canonical) continue;
+      const type = canonical ?? node.type;
+      out.push({ id: node.id, type, definition: { type, name: node.name, fieldDefinitions: node.fieldDefinitions } });
+    }
+    after = data.metaobjectDefinitions.pageInfo.hasNextPage ? data.metaobjectDefinitions.pageInfo.endCursor : null;
+  } while (after !== null);
+  return out;
+}
+
+// src/sync/push.ts
+function fieldInputFor(defByType, type, key) {
+  return defByType.get(type)?.fieldDefinitions.find((f) => f.key === key);
+}
+function referenceEdges(def) {
+  const out = [];
+  for (const field of def.fieldDefinitions) {
+    for (const v2 of field.validations) {
+      if (v2.name === "metaobject_definition_type") {
+        out.push(v2.value);
+      } else if (v2.name === "metaobject_definition_types") {
+        try {
+          const parsed = JSON.parse(v2.value);
+          if (Array.isArray(parsed)) {
+            for (const t of parsed) if (typeof t === "string") out.push(t);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return out;
+}
+function topoSortCreates(types, deps) {
+  const remaining = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const t of types) {
+    const d = deps.get(t) ?? /* @__PURE__ */ new Set();
+    remaining.set(t, d.size);
+    for (const dep of d) {
+      const list2 = dependents.get(dep) ?? [];
+      list2.push(t);
+      dependents.set(dep, list2);
+    }
+  }
+  const queue = [];
+  for (const t of types) if ((remaining.get(t) ?? 0) === 0) queue.push(t);
+  const ordered = [];
+  while (queue.length) {
+    const t = queue.shift();
+    ordered.push(t);
+    for (const dependent of dependents.get(t) ?? []) {
+      const r = (remaining.get(dependent) ?? 0) - 1;
+      remaining.set(dependent, r);
+      if (r === 0) queue.push(dependent);
+    }
+  }
+  const orderedSet = new Set(ordered);
+  return { ordered, unordered: [...types].filter((t) => !orderedSet.has(t)) };
+}
+async function push(client, plan, sources, options) {
+  const allowDestructive = options?.allowDestructive ?? false;
+  const defByType = new Map(sources.definitions.map((d) => [d.type, d]));
+  const idByType = new Map(sources.remote.map((r) => [r.type, r.id]));
+  const indexed = plan.map((op, index) => ({ op, index }));
+  const createOps = indexed.filter((x) => x.op.kind === "createDefinition");
+  const otherOps = indexed.filter((x) => x.op.kind !== "createDefinition");
+  const createTypes = new Set(createOps.map((x) => x.op.type));
+  const deps = /* @__PURE__ */ new Map();
+  for (const { op } of createOps) {
+    const def = defByType.get(op.type);
+    const targets = def ? referenceEdges(def) : [];
+    deps.set(op.type, new Set(targets.filter((t) => createTypes.has(t) && t !== op.type)));
+  }
+  const { ordered, unordered } = topoSortCreates(createTypes, deps);
+  const orderedSet = new Set(ordered);
+  const cyclicTypes = new Set(unordered);
+  const createByType = new Map(createOps.map((x) => [x.op.type, x]));
+  const execOrder = [
+    ...ordered.map((t) => createByType.get(t)),
+    ...createOps.filter((x) => !orderedSet.has(x.op.type)),
+    ...otherOps
+  ];
+  const failedTypes = /* @__PURE__ */ new Set();
+  async function applyOp(op) {
+    if (op.kind === "createDefinition") {
+      if (cyclicTypes.has(op.type)) {
+        failedTypes.add(op.type);
+        return { op, status: "blocked", reason: "reference cycle \u2014 two-pass create deferred" };
+      }
+      for (const dep of deps.get(op.type) ?? []) {
+        if (failedTypes.has(dep)) {
+          failedTypes.add(op.type);
+          return { op, status: "blocked", reason: `blocked: dependency "${dep}" was not created` };
+        }
+      }
+      const def = defByType.get(op.type);
+      if (!def) {
+        failedTypes.add(op.type);
+        return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+      }
+      const data2 = await execute(client, CREATE_DEFINITION_MUTATION, { definition: def });
+      const payload2 = data2.metaobjectDefinitionCreate;
+      if (payload2.userErrors.length) {
+        failedTypes.add(op.type);
+        return { op, status: "failed", userErrors: payload2.userErrors };
+      }
+      const id2 = payload2.metaobjectDefinition?.id;
+      if (id2) idByType.set(op.type, id2);
+      return { op, status: "applied", id: id2 };
+    }
+    const destructive = op.kind === "removeField" || op.kind === "changeFieldType";
+    if (destructive && !allowDestructive) return { op, status: "skipped", reason: "destructive" };
+    if (failedTypes.has(op.type)) return { op, status: "blocked", reason: `blocked: definition "${op.type}" was not created` };
+    const id = idByType.get(op.type);
+    if (id == null) return { op, status: "blocked", reason: `no definition id for "${op.type}"` };
+    const fieldDefinitions = fieldOpsFor(op);
+    if (!fieldDefinitions) return { op, status: "blocked", reason: `no field input for "${op.type}"` };
+    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition: { fieldDefinitions } });
+    const payload = data.metaobjectDefinitionUpdate;
+    if (payload.userErrors.length) return { op, status: "failed", userErrors: payload.userErrors };
+    return { op, status: "applied", id: payload.metaobjectDefinition?.id ?? id };
+  }
+  function fieldOpsFor(op) {
+    switch (op.kind) {
+      case "addField": {
+        const field = fieldInputFor(defByType, op.type, op.field.key);
+        return field ? [{ create: field }] : void 0;
+      }
+      case "updateField": {
+        const field = fieldInputFor(defByType, op.type, op.key);
+        if (!field) return void 0;
+        const update = {
+          key: field.key,
+          name: field.name,
+          required: field.required,
+          validations: field.validations
+        };
+        if (field.description != null) update.description = field.description;
+        return [{ update }];
+      }
+      case "removeField":
+        return [{ delete: { key: op.key } }];
+      case "changeFieldType": {
+        const field = fieldInputFor(defByType, op.type, op.key);
+        return field ? [{ delete: { key: op.key } }, { create: field }] : void 0;
+      }
+      default:
+        return void 0;
+    }
+  }
+  const results = new Array(plan.length);
+  for (const { op, index } of execOrder) results[index] = await applyOp(op);
+  const counts = { applied: 0, skipped: 0, blocked: 0, failed: 0 };
+  for (const r of results) counts[r.status]++;
+  return { results, counts, ok: counts.failed === 0 && counts.blocked === 0 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_API_VERSION,
+  Field,
+  SyncTransportError,
+  defineConfig,
+  defineMetaobject,
+  diff,
+  generateSchemaSource,
+  m,
+  normalizeLocal,
+  normalizeRemote,
+  pull,
+  pullAll,
+  push,
+  toDefinitionInput,
+  validateConfig
+});
+//# sourceMappingURL=index.cjs.map