@fmaplabs/meta-manifest 0.2.0 → 0.4.0

package/dist/{chunk-GH5DXHS5.js → chunk-OEJJXMYC.js}

@@ -4,7 +4,7 @@ import {
   PULL_DEFINITION_QUERY,
   UPDATE_DEFINITION_MUTATION,
   execute
-} from "./chunk-3R6VQ3Z3.js";
+} from "./chunk-VSJUGUH7.js";
 
 // src/fields/base.ts
 var Field = class {
@@ -13,6 +13,14 @@ var Field = class {
   required = false;
   name;
   description;
+  filterable = false;
+  /** Apply the shared field options; call from each concrete constructor. */
+  applyCommon(opts) {
+    this.required = opts.required ?? false;
+    this.name = opts.name;
+    this.description = opts.description;
+    this.filterable = opts.filterable ?? false;
+  }
   /** Constraint validation on an already-typed value. */
   check(_value) {
     return [];
@@ -69,9 +77,7 @@ var BooleanField = class extends Field {
   shopifyType = "boolean";
   constructor(opts) {
     super();
-    this.required = opts.required ?? false;
-    this.name = opts.name;
-    this.description = opts.description;
+    this.applyCommon(opts);
   }
   validations() {
     return [];
@@ -97,9 +103,7 @@ var ListField = class extends Field {
     this.inner = inner;
     this.o = o;
     this.shopifyType = `list.${inner.shopifyType}`;
-    this.required = o.required ?? false;
-    this.name = o.name;
-    this.description = o.description;
+    this.applyCommon(o);
   }
   inner;
   o;
@@ -135,9 +139,7 @@ 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;
+    this.applyCommon(opts);
   }
   shopifyType;
   wireIsJson = true;
@@ -173,9 +175,7 @@ var MoneyField = class extends Field {
   wireIsJson = true;
   constructor(opts) {
     super();
-    this.required = opts.required ?? false;
-    this.name = opts.name;
-    this.description = opts.description;
+    this.applyCommon(opts);
   }
   validations() {
     return [];
@@ -201,9 +201,7 @@ var NumericField = class extends Field {
   constructor(opts) {
     super();
     this.opts = opts;
-    this.required = opts.required ?? false;
-    this.name = opts.name;
-    this.description = opts.description;
+    this.applyCommon(opts);
   }
   opts;
   toJson(value) {
@@ -268,9 +266,7 @@ var RatingField = class extends Field {
   constructor(o) {
     super();
     this.o = o;
-    this.required = o.required ?? false;
-    this.name = o.name;
-    this.description = o.description;
+    this.applyCommon(o);
   }
   o;
   shopifyType = "rating";
@@ -325,9 +321,7 @@ function rating(opts) {
 var GidField = class extends Field {
   constructor(opts) {
     super();
-    this.required = opts.required ?? false;
-    this.name = opts.name;
-    this.description = opts.description;
+    this.applyCommon(opts);
   }
   toJson(value) {
     return value;
@@ -372,6 +366,17 @@ var MetaobjectRefField = class extends GidField {
     return [{ name: "metaobject_definition_type", value: resolveType(this.target) }];
   }
 };
+var MixedRefField = class extends GidField {
+  constructor(targets, opts) {
+    super(opts);
+    this.targets = targets;
+  }
+  targets;
+  shopifyType = "mixed_reference";
+  validations() {
+    return [{ name: "metaobject_definition_types", value: JSON.stringify(this.targets.map(resolveType)) }];
+  }
+};
 function product(opts = {}) {
   return new SimpleRefField(opts, "product_reference");
 }
@@ -390,14 +395,15 @@ function file(opts = {}) {
 function ref(target, opts = {}) {
   return new MetaobjectRefField(target, opts);
 }
+function mixedRef(targets, opts = {}) {
+  return new MixedRefField(targets, 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;
+    this.applyCommon(opts);
   }
   toJson(value) {
     return value;
@@ -447,9 +453,7 @@ var JsonField = class extends Field {
   wireIsJson = true;
   constructor(opts) {
     super();
-    this.required = opts.required ?? false;
-    this.name = opts.name;
-    this.description = opts.description;
+    this.applyCommon(opts);
   }
   validations() {
     return [];
@@ -483,9 +487,7 @@ var TextField = class extends Field {
     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;
+    this.applyCommon(opts);
   }
   opts;
   shopifyType;
@@ -544,6 +546,7 @@ var m = {
   page,
   file,
   ref,
+  mixedRef,
   list
 };
 
@@ -553,16 +556,44 @@ function mapAccess(access) {
   const out = {};
   if (access.admin) out.admin = access.admin.toUpperCase();
   if (access.storefront) out.storefront = access.storefront.toUpperCase();
+  if (access.customerAccount) out.customerAccount = access.customerAccount.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 };
+  if (caps.publishable != null) out.publishable = { enabled: caps.publishable };
+  if (caps.translatable != null) out.translatable = { enabled: caps.translatable };
+  if (caps.renderable != null) {
+    if (typeof caps.renderable === "boolean") {
+      out.renderable = { enabled: caps.renderable };
+    } else {
+      const data = {};
+      if (caps.renderable.metaTitleKey != null) data.metaTitleKey = caps.renderable.metaTitleKey;
+      if (caps.renderable.metaDescriptionKey != null) data.metaDescriptionKey = caps.renderable.metaDescriptionKey;
+      out.renderable = Object.keys(data).length ? { enabled: true, data } : { enabled: true };
+    }
+  }
+  if (caps.onlineStore != null) {
+    const data = { urlHandle: caps.onlineStore.urlHandle };
+    if (caps.onlineStore.createRedirects != null) data.createRedirects = caps.onlineStore.createRedirects;
+    out.onlineStore = { enabled: true, data };
+  }
   return Object.keys(out).length ? out : void 0;
 }
+function validateSeoKeys(caps, fieldKeys, name) {
+  const r = caps?.renderable;
+  if (!r || typeof r === "boolean") return;
+  for (const prop of ["metaTitleKey", "metaDescriptionKey"]) {
+    const key = r[prop];
+    if (key != null && !fieldKeys.has(key)) {
+      throw new Error(`renderable.${prop} "${key}" is not a declared field key on "${name}".`);
+    }
+  }
+}
 function toDefinitionInput(schema) {
   const { config } = schema;
+  validateSeoKeys(config.capabilities, new Set(Object.keys(schema.fields)), config.name);
   const fieldDefinitions = Object.entries(schema.fields).map(([key, field]) => {
     const def = {
       key,
@@ -572,6 +603,7 @@ function toDefinitionInput(schema) {
       validations: field.validations()
     };
     if (field.description != null) def.description = field.description;
+    if (field.filterable) def.capabilities = { adminFilterable: { enabled: true } };
     return def;
   });
   const out = {
@@ -644,6 +676,12 @@ function defineMetaobject(handle, config) {
 
 // src/codegen.ts
 var APP_PREFIX = "$app:";
+function isMerchant(type) {
+  return !type.startsWith(APP_PREFIX);
+}
+function filterableEntry(field) {
+  return field.filterable ? ["filterable: true"] : [];
+}
 var SIMPLE = {
   single_line_text_field: "text",
   multi_line_text_field: "multilineText",
@@ -687,6 +725,27 @@ function refTarget(field) {
   }
   return void 0;
 }
+function refTargets(field) {
+  const many = v(field.validations, "metaobject_definition_types");
+  if (many) {
+    try {
+      const arr = JSON.parse(many);
+      if (Array.isArray(arr)) return arr.map(String);
+    } catch {
+    }
+  }
+  const single = v(field.validations, "metaobject_definition_type");
+  return single ? [single] : [];
+}
+function mixedTargetsLiteral(field, typeToIdent, warnings) {
+  const targets = refTargets(field);
+  const idents = targets.map((t) => typeToIdent.get(t));
+  if (!targets.length || idents.some((i) => !i)) {
+    warnings.push(`unresolved mixed reference on field "${field.key}"`);
+    return void 0;
+  }
+  return `[${idents.map((i) => `() => ${i}`).join(", ")}]`;
+}
 function optsLiteral(entries) {
   return entries.length ? `{ ${entries.join(", ")} }` : "";
 }
@@ -725,8 +784,8 @@ function scalarEntries(field, warnings, builder) {
   jsonArr("file_type_options", "accept");
   return e;
 }
-function scalarCall(builder, field, warnings) {
-  const lit = optsLiteral(scalarEntries(field, warnings, builder));
+function scalarCall(builder, field, warnings, extra = []) {
+  const lit = optsLiteral([...scalarEntries(field, warnings, builder), ...extra]);
   return lit ? `m.${builder}(${lit})` : `m.${builder}()`;
 }
 function fieldCall(field, typeToIdent, warnings) {
@@ -736,6 +795,7 @@ function fieldCall(field, typeToIdent, warnings) {
     const max = v(field.validations, "max");
     const e = [`min: ${Number(min ?? 1)}`, `max: ${Number(max ?? 5)}`];
     if (field.required) e.unshift("required: true");
+    e.push(...filterableEntry(field));
     if (min === void 0 || max === void 0) warnings.push(`rating field "${field.key}" missing min/max`);
     return `m.rating(${optsLiteral(e)})`;
   }
@@ -746,7 +806,20 @@ function fieldCall(field, typeToIdent, warnings) {
       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})`;
+    const refEntries = [];
+    if (field.required) refEntries.push("required: true");
+    refEntries.push(...filterableEntry(field));
+    const opts = optsLiteral(refEntries);
+    return opts ? `m.ref(() => ${ident}, ${opts})` : `m.ref(() => ${ident})`;
+  }
+  if (type === "mixed_reference") {
+    const arr = mixedTargetsLiteral(field, typeToIdent, warnings);
+    if (!arr) return `m.json() /* TODO: unmapped mixed reference */`;
+    const refEntries = [];
+    if (field.required) refEntries.push("required: true");
+    refEntries.push(...filterableEntry(field));
+    const opts = optsLiteral(refEntries);
+    return opts ? `m.mixedRef(${arr}, ${opts})` : `m.mixedRef(${arr})`;
   }
   if (type.startsWith("list.")) {
     const inner = type.slice("list.".length);
@@ -756,6 +829,7 @@ function fieldCall(field, typeToIdent, warnings) {
     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)}`);
+    listEntries.push(...filterableEntry(field));
     const listOpts = optsLiteral(listEntries);
     let innerCall;
     if (inner === "metaobject_reference") {
@@ -766,6 +840,10 @@ function fieldCall(field, typeToIdent, warnings) {
         return `m.json() /* TODO: unmapped list reference */`;
       }
       innerCall = `m.ref(() => ${ident})`;
+    } else if (inner === "mixed_reference") {
+      const arr = mixedTargetsLiteral(field, typeToIdent, warnings);
+      if (!arr) return `m.json() /* TODO: unmapped list mixed reference */`;
+      innerCall = `m.mixedRef(${arr})`;
     } else if (SIMPLE[inner]) {
       innerCall = scalarCall(SIMPLE[inner], { ...field, required: false }, warnings);
     } else {
@@ -774,17 +852,53 @@ function fieldCall(field, typeToIdent, warnings) {
     }
     return listOpts ? `m.list(${innerCall}, ${listOpts})` : `m.list(${innerCall})`;
   }
-  if (SIMPLE[type]) return scalarCall(SIMPLE[type], field, warnings);
+  if (SIMPLE[type]) return scalarCall(SIMPLE[type], field, warnings, filterableEntry(field));
   warnings.push(`unmapped field type "${type}" on field "${field.key}"`);
   return `m.json() /* TODO: unmapped type ${type} */`;
 }
+function accessSource(access) {
+  if (!access) return "";
+  const parts = [];
+  if (access.admin === "MERCHANT_READ_WRITE") parts.push(`admin: "merchant_read_write"`);
+  if (access.storefront === "PUBLIC_READ") parts.push(`storefront: "public_read"`);
+  if (access.customerAccount === "READ") parts.push(`customerAccount: "read"`);
+  return parts.length ? `{ ${parts.join(", ")} }` : "";
+}
+function capabilitiesSource(caps) {
+  if (!caps) return "";
+  const parts = [];
+  if (caps.publishable?.enabled) parts.push(`publishable: true`);
+  if (caps.translatable?.enabled) parts.push(`translatable: true`);
+  if (caps.renderable?.enabled) {
+    const d = caps.renderable.data;
+    const dparts = [];
+    if (d?.metaTitleKey != null) dparts.push(`metaTitleKey: ${JSON.stringify(d.metaTitleKey)}`);
+    if (d?.metaDescriptionKey != null) dparts.push(`metaDescriptionKey: ${JSON.stringify(d.metaDescriptionKey)}`);
+    parts.push(dparts.length ? `renderable: { ${dparts.join(", ")} }` : `renderable: true`);
+  }
+  if (caps.onlineStore?.enabled && caps.onlineStore.data?.urlHandle != null) {
+    parts.push(`onlineStore: { urlHandle: ${JSON.stringify(caps.onlineStore.data.urlHandle)} }`);
+  }
+  return parts.length ? `{ ${parts.join(", ")} }` : "";
+}
+function defConfigLines(def) {
+  const lines = [];
+  if (isMerchant(def.type)) lines.push(`  scope: "merchant",`);
+  if (def.name) lines.push(`  name: ${JSON.stringify(def.name)},`);
+  if (def.description != null) lines.push(`  description: ${JSON.stringify(def.description)},`);
+  if (def.displayNameKey != null) lines.push(`  displayName: ${JSON.stringify(def.displayNameKey)},`);
+  const access = accessSource(def.access);
+  if (access) lines.push(`  access: ${access},`);
+  const caps = capabilitiesSource(def.capabilities);
+  if (caps) lines.push(`  capabilities: ${caps},`);
+  return lines.length ? `
+${lines.join("\n")}` : "";
+}
 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}
+  return `export const ${ident} = defineMetaobject(${JSON.stringify(handle)}, {${defConfigLines(def)}
   fields: {
 ${fields}
   },
@@ -796,6 +910,8 @@ function referencedTypes(def) {
     if (f.type === "metaobject_reference" || f.type === "list.metaobject_reference") {
       const t = refTarget(f);
       if (t) out.add(t);
+    } else if (f.type === "mixed_reference" || f.type === "list.mixed_reference") {
+      for (const t of refTargets(f)) out.add(t);
     }
   }
   return out;
@@ -844,6 +960,42 @@ function sameValidations(a, b) {
   const norm = (v2) => JSON.stringify([...v2].sort((x, y) => x.name.localeCompare(y.name)));
   return norm(a) === norm(b);
 }
+var CAP_KEYS = ["publishable", "translatable", "renderable", "onlineStore"];
+function accessChanged(local, remote) {
+  for (const key of ["admin", "storefront", "customerAccount"]) {
+    const lv = local[key];
+    if (lv != null && remote?.[key] !== lv) return true;
+  }
+  return false;
+}
+function capabilitiesChanged(local, remote) {
+  for (const key of CAP_KEYS) {
+    const lc = local[key];
+    if (!lc) continue;
+    const rc = remote?.[key];
+    if ((rc?.enabled ?? false) !== lc.enabled) return true;
+    const ldata = lc.data;
+    if (ldata) {
+      const rdata = rc?.data;
+      for (const [k, v2] of Object.entries(ldata)) {
+        if (v2 != null && rdata?.[k] !== v2) return true;
+      }
+    }
+  }
+  return false;
+}
+function disablesOnlineStore(local, remote) {
+  return local.onlineStore?.enabled === false && remote?.onlineStore?.enabled === true;
+}
+function definitionChanges(local, remote) {
+  const changes = [];
+  if (local.name != null && local.name !== remote.name) changes.push("name");
+  if (local.description != null && local.description !== remote.description) changes.push("description");
+  if (local.displayNameKey != null && local.displayNameKey !== remote.displayNameKey) changes.push("displayNameKey");
+  if (local.access && accessChanged(local.access, remote.access)) changes.push("access");
+  if (local.capabilities && capabilitiesChanged(local.capabilities, remote.capabilities)) changes.push("capabilities");
+  return changes;
+}
 function diff(local, remote) {
   const ops = [];
   const remoteByType = new Map(remote.map((d) => [d.type, d]));
@@ -867,6 +1019,7 @@ function diff(local, remote) {
       }
       const changes = {};
       if (rf.required !== lf.required) changes.required = lf.required;
+      if (rf.filterable !== lf.filterable) changes.filterable = lf.filterable;
       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 });
@@ -877,49 +1030,179 @@ function diff(local, remote) {
         ops.push({ kind: "removeField", type: localDef.type, key: rf.key, destructive: true });
       }
     }
+    const metaChanges = definitionChanges(localDef, remoteDef);
+    if (metaChanges.length) {
+      const destructive = localDef.capabilities ? disablesOnlineStore(localDef.capabilities, remoteDef.capabilities) : false;
+      ops.push({
+        kind: "updateDefinition",
+        type: localDef.type,
+        changes: metaChanges,
+        ...destructive ? { destructive: true } : {}
+      });
+    }
   }
   return ops;
 }
 
 // src/sync/normalize.ts
-function normalizeLocal(schema) {
-  const def = schema.toDefinitionInput();
-  return {
+function localCapabilities(caps) {
+  const out = {};
+  if (caps?.publishable) out.publishable = { enabled: caps.publishable.enabled };
+  if (caps?.translatable) out.translatable = { enabled: caps.translatable.enabled };
+  if (caps?.renderable) {
+    out.renderable = { enabled: caps.renderable.enabled };
+    if (caps.renderable.data) out.renderable.data = { ...caps.renderable.data };
+  }
+  out.onlineStore = caps?.onlineStore ? { enabled: caps.onlineStore.enabled, data: { urlHandle: caps.onlineStore.data?.urlHandle } } : { enabled: false };
+  return out;
+}
+function normalizeDefinition(def) {
+  const out = {
     type: def.type,
     name: def.name,
+    capabilities: localCapabilities(def.capabilities),
     fields: def.fieldDefinitions.map((f) => ({
       key: f.key,
       type: f.type,
       required: f.required,
+      filterable: f.capabilities?.adminFilterable?.enabled ?? false,
       validations: f.validations
     }))
   };
+  if (def.description != null) out.description = def.description;
+  if (def.displayNameKey != null) out.displayNameKey = def.displayNameKey;
+  if (def.access) out.access = { ...def.access };
+  return out;
+}
+function normalizeLocal(schema) {
+  return normalizeDefinition(schema.toDefinitionInput());
+}
+function remoteAccess(access) {
+  if (!access) return void 0;
+  const out = {};
+  if (access.admin != null) out.admin = access.admin;
+  if (access.storefront != null) out.storefront = access.storefront;
+  if (access.customerAccount != null) out.customerAccount = access.customerAccount;
+  return out;
+}
+function remoteCapabilities(caps) {
+  const out = {};
+  if (!caps) return out;
+  if (caps.publishable) out.publishable = { enabled: !!caps.publishable.enabled };
+  if (caps.translatable) out.translatable = { enabled: !!caps.translatable.enabled };
+  if (caps.renderable) {
+    out.renderable = { enabled: !!caps.renderable.enabled };
+    const d = caps.renderable.data;
+    if (d) {
+      const data = {};
+      if (d.metaTitleKey != null) data.metaTitleKey = d.metaTitleKey;
+      if (d.metaDescriptionKey != null) data.metaDescriptionKey = d.metaDescriptionKey;
+      if (Object.keys(data).length) out.renderable.data = data;
+    }
+  }
+  if (caps.onlineStore) {
+    out.onlineStore = { enabled: !!caps.onlineStore.enabled };
+    if (caps.onlineStore.data?.urlHandle != null) out.onlineStore.data = { urlHandle: caps.onlineStore.data.urlHandle };
+  }
+  return out;
 }
 function normalizeRemote(def) {
-  return {
+  const out = {
     type: def.type,
     name: def.name,
+    capabilities: remoteCapabilities(def.capabilities),
     fields: def.fieldDefinitions.map((f) => ({
       key: f.key,
       type: typeof f.type === "string" ? f.type : f.type.name,
       required: f.required,
+      filterable: f.capabilities?.adminFilterable?.enabled ?? false,
       validations: f.validations ?? []
     }))
   };
+  if (def.description != null) out.description = def.description;
+  if (def.displayNameKey != null) out.displayNameKey = def.displayNameKey;
+  const access = remoteAccess(def.access);
+  if (access) out.access = access;
+  return out;
+}
+
+// src/sync/resolve.ts
+var APP_PREFIX2 = "$app:";
+function effectiveScope(schema, config) {
+  return schema.config.scope ?? config.scope ?? "app";
+}
+function effectiveType(handle, scope) {
+  return scope === "merchant" ? handle : `${APP_PREFIX2}${handle}`;
+}
+function rewriteReference(v2, effByCanonical) {
+  if (v2.name === "metaobject_definition_type") {
+    const mapped = effByCanonical.get(v2.value);
+    return mapped ? { ...v2, value: mapped } : v2;
+  }
+  if (v2.name === "metaobject_definition_types") {
+    try {
+      const parsed = JSON.parse(v2.value);
+      if (Array.isArray(parsed)) {
+        const rewritten = parsed.map((t) => typeof t === "string" ? effByCanonical.get(t) ?? t : t);
+        return { ...v2, value: JSON.stringify(rewritten) };
+      }
+    } catch {
+    }
+  }
+  return v2;
+}
+function resolveAdmin(out, handle, scope, config) {
+  const explicitAdmin = out.access?.admin;
+  if (scope === "merchant") {
+    if (explicitAdmin != null) {
+      throw new Error(
+        `"${handle}" is merchant-scoped but sets access.admin; admin access is only valid on app-scoped metaobjects.`
+      );
+    }
+    return;
+  }
+  if (explicitAdmin == null) {
+    const admin = config.merchantEditable ? "MERCHANT_READ_WRITE" : "MERCHANT_READ";
+    out.access = { ...out.access, admin };
+  }
+}
+function resolveDefinitions(schemas, config = {}) {
+  const effByCanonical = /* @__PURE__ */ new Map();
+  for (const s of schemas) {
+    effByCanonical.set(`${APP_PREFIX2}${s.handle}`, effectiveType(s.handle, effectiveScope(s, config)));
+  }
+  return schemas.map((s) => {
+    const scope = effectiveScope(s, config);
+    const base = s.toDefinitionInput();
+    const fieldDefinitions = base.fieldDefinitions.map((f) => ({
+      ...f,
+      validations: f.validations.map((v2) => rewriteReference(v2, effByCanonical))
+    }));
+    const out = { ...base, type: effectiveType(s.handle, scope), fieldDefinitions };
+    resolveAdmin(out, s.handle, scope, config);
+    return out;
+  });
 }
 
 // src/sync/pull.ts
+function toDefinition(type, node) {
+  return {
+    type,
+    name: node.name,
+    description: node.description,
+    displayNameKey: node.displayNameKey,
+    access: node.access,
+    capabilities: node.capabilities,
+    fieldDefinitions: node.fieldDefinitions
+  };
+}
 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 }
-    });
+    out.push({ id: node.id, type, definition: toDefinition(type, node) });
   }
   return out;
 }
@@ -937,7 +1220,7 @@ async function pullAll(client, opts = {}) {
       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 } });
+      out.push({ id: node.id, type, definition: toDefinition(type, node) });
     }
     after = data.metaobjectDefinitions.pageInfo.hasNextPage ? data.metaobjectDefinitions.pageInfo.endCursor : null;
   } while (after !== null);
@@ -945,28 +1228,57 @@ async function pullAll(client, opts = {}) {
 }
 
 // src/sync/push.ts
+function definitionUpdateFor(def, changes) {
+  const out = {};
+  for (const c of changes) {
+    if (c === "name") out.name = def.name;
+    else if (c === "description") out.description = def.description;
+    else if (c === "displayNameKey") out.displayNameKey = def.displayNameKey;
+    else if (c === "access") out.access = def.access;
+    else if (c === "capabilities") {
+      const caps = def.capabilities;
+      const payload = {};
+      if (caps?.publishable) payload.publishable = caps.publishable;
+      if (caps?.translatable) payload.translatable = caps.translatable;
+      if (caps?.renderable) payload.renderable = caps.renderable;
+      payload.onlineStore = caps?.onlineStore ?? { enabled: false };
+      out.capabilities = payload;
+    }
+  }
+  return out;
+}
 function fieldInputFor(defByType, type, key) {
   return defByType.get(type)?.fieldDefinitions.find((f) => f.key === key);
 }
-function referenceEdges(def) {
+function fieldRefTargets(field) {
   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 {
+  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 referenceEdges(def) {
+  return def.fieldDefinitions.flatMap(fieldRefTargets);
+}
+function splitCyclicFields(def, cyclicTypes) {
+  const pass1 = [];
+  const deferred = [];
+  for (const f of def.fieldDefinitions) {
+    const breaksCycle = fieldRefTargets(f).some((t) => cyclicTypes.has(t) && t !== def.type);
+    (breaksCycle ? deferred : pass1).push(f);
+  }
+  return { pass1, deferred };
+}
 function topoSortCreates(types, deps) {
   const remaining = /* @__PURE__ */ new Map();
   const dependents = /* @__PURE__ */ new Map();
@@ -1009,50 +1321,51 @@ async function push(client, plan, sources, options) {
     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) {
+  async function createDefinition(op, definition) {
+    const data = await execute(client, CREATE_DEFINITION_MUTATION, { definition });
+    const payload = data.metaobjectDefinitionCreate;
+    if (payload.userErrors.length) {
+      failedTypes.add(op.type);
+      return { op, status: "failed", userErrors: payload.userErrors };
+    }
+    const id = payload.metaobjectDefinition?.id;
+    if (id) idByType.set(op.type, id);
+    return { op, status: "applied", id };
+  }
+  async function applyAcyclicCreate(op) {
+    for (const dep of deps.get(op.type) ?? []) {
+      if (failedTypes.has(dep)) {
         failedTypes.add(op.type);
-        return { op, status: "failed", userErrors: payload2.userErrors };
+        return { op, status: "blocked", reason: `blocked: dependency "${dep}" was not created` };
       }
-      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";
+    const def = defByType.get(op.type);
+    if (!def) {
+      failedTypes.add(op.type);
+      return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+    }
+    return createDefinition(op, def);
+  }
+  async function applyFieldOp(op) {
+    const destructive = "destructive" in op && op.destructive === true;
     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 } });
+    let definition;
+    if (op.kind === "updateDefinition") {
+      const def = defByType.get(op.type);
+      if (!def) return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+      definition = definitionUpdateFor(def, op.changes);
+    } else {
+      const fieldDefinitions = fieldOpsFor(op);
+      if (!fieldDefinitions) return { op, status: "blocked", reason: `no field input for "${op.type}"` };
+      definition = { fieldDefinitions };
+    }
+    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition });
     const payload = data.metaobjectDefinitionUpdate;
     if (payload.userErrors.length) return { op, status: "failed", userErrors: payload.userErrors };
     return { op, status: "applied", id: payload.metaobjectDefinition?.id ?? id };
@@ -1073,6 +1386,9 @@ async function push(client, plan, sources, options) {
           validations: field.validations
         };
         if (field.description != null) update.description = field.description;
+        if ("filterable" in op.changes) {
+          update.capabilities = { adminFilterable: { enabled: op.changes.filterable ?? false } };
+        }
         return [{ update }];
       }
       case "removeField":
@@ -1086,7 +1402,53 @@ async function push(client, plan, sources, options) {
     }
   }
   const results = new Array(plan.length);
-  for (const { op, index } of execOrder) results[index] = await applyOp(op);
+  for (const type of ordered) {
+    const entry = createByType.get(type);
+    results[entry.index] = await applyAcyclicCreate(entry.op);
+  }
+  const cyclicCreates = createOps.filter((x) => cyclicTypes.has(x.op.type));
+  const deferredByType = /* @__PURE__ */ new Map();
+  for (const { op, index } of cyclicCreates) {
+    const def = defByType.get(op.type);
+    if (!def) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+      continue;
+    }
+    const failedDep = [...deps.get(op.type) ?? []].find((d) => !cyclicTypes.has(d) && failedTypes.has(d));
+    if (failedDep) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "blocked", reason: `blocked: dependency "${failedDep}" was not created` };
+      continue;
+    }
+    const { pass1, deferred } = splitCyclicFields(def, cyclicTypes);
+    deferredByType.set(op.type, deferred);
+    results[index] = await createDefinition(op, { ...def, fieldDefinitions: pass1 });
+  }
+  for (const { op, index } of cyclicCreates) {
+    if (results[index]?.status !== "applied") continue;
+    const deferred = deferredByType.get(op.type) ?? [];
+    if (!deferred.length) continue;
+    const failedTarget = deferred.flatMap(fieldRefTargets).find((t) => failedTypes.has(t));
+    if (failedTarget) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "blocked", reason: `blocked: dependency "${failedTarget}" was not created` };
+      continue;
+    }
+    const id = idByType.get(op.type);
+    if (id == null) {
+      results[index] = { op, status: "blocked", reason: `no definition id for "${op.type}"` };
+      continue;
+    }
+    const definition = { fieldDefinitions: deferred.map((f) => ({ create: f })) };
+    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition });
+    const payload = data.metaobjectDefinitionUpdate;
+    if (payload.userErrors.length) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "failed", userErrors: payload.userErrors };
+    }
+  }
+  for (const { op, index } of otherOps) results[index] = await applyFieldOp(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 };
@@ -1099,10 +1461,12 @@ export {
   defineMetaobject,
   generateSchemaSource,
   diff,
+  normalizeDefinition,
   normalizeLocal,
   normalizeRemote,
+  resolveDefinitions,
   pull,
   pullAll,
   push
 };
-//# sourceMappingURL=chunk-GH5DXHS5.js.map
+//# sourceMappingURL=chunk-OEJJXMYC.js.map