@relyio/sdk 0.13.0 → 0.14.0

package/dist/{chunk-EW23SZPX.js → chunk-PCFTJLEP.js}

@@ -2,11 +2,362 @@ import { __name, __export } from './chunk-XQ4QHWZE.js';
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
 
+// src/schema/fields/keyed.ts
+var KEYED_FIELD_OPTIONS = [
+  "displayName",
+  "description",
+  "ui",
+  "ai",
+  "rules",
+  "localized",
+  "fallback",
+  "deprecated"
+];
+function keyedField(type, options) {
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw new Error(
+      `fields.${type} takes one options object: the id-first form, fields.${type}('id', { config }), was removed in 0.14. Write the Field under its key, as id: fields.${type}({ \u2026 })`
+    );
+  }
+  return { _tag: "keyedField", type, options: { ...options } };
+}
+__name(keyedField, "keyedField");
+function labelFromKey(key) {
+  const words = key.replace(/[_\-\s]+/g, " ").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").trim().split(/\s+/).filter((word) => word.length > 0);
+  return words.map((word, index) => {
+    const acronym = word.length > 1 && word === word.toUpperCase() && /[A-Z]/.test(word);
+    const cased = acronym ? word : word.toLowerCase();
+    return index === 0 ? cased.charAt(0).toUpperCase() + cased.slice(1) : cased;
+  }).join(" ");
+}
+__name(labelFromKey, "labelFromKey");
+function isKeyedField(value) {
+  return typeof value === "object" && value !== null && value._tag === "keyedField";
+}
+__name(isKeyedField, "isKeyedField");
+function localizationOf(localized, id) {
+  if (localized === true) return true;
+  if (typeof localized === "object" && localized !== null && !Array.isArray(localized)) {
+    const { requiredLocales, fallback } = localized;
+    return {
+      enabled: true,
+      ...requiredLocales !== void 0 && { requiredLocales },
+      ...fallback !== void 0 && { fallback }
+    };
+  }
+  throw new Error(
+    `Field '${id}' has localized: ${JSON.stringify(localized)}. It takes true, or { requiredLocales, fallback } \u2014 leave it out for a Field every locale shares`
+  );
+}
+__name(localizationOf, "localizationOf");
+function compileKeyedField(id, field) {
+  const config = {};
+  const shared = {};
+  const sharedNames = new Set(KEYED_FIELD_OPTIONS);
+  for (const [key, value] of Object.entries(field.options)) {
+    if (value === void 0) continue;
+    if (sharedNames.has(key)) shared[key] = value;
+    else config[key] = value;
+  }
+  return {
+    id,
+    type: field.type,
+    ...Object.keys(config).length > 0 && { config },
+    ui: {
+      displayName: typeof shared.displayName === "string" ? shared.displayName : labelFromKey(id),
+      ...shared.description !== void 0 && { description: shared.description },
+      ...shared.ui !== void 0 && { options: shared.ui }
+    },
+    ...shared.ai !== void 0 && { ai: shared.ai },
+    ...shared.rules !== void 0 && { rules: shared.rules },
+    ...shared.localized !== void 0 && { localization: localizationOf(shared.localized, id) },
+    ...shared.fallback !== void 0 && { fallback: shared.fallback },
+    ...shared.deprecated !== void 0 && { deprecated: shared.deprecated }
+  };
+}
+__name(compileKeyedField, "compileKeyedField");
+function isSection(value) {
+  return typeof value === "object" && value !== null && !("type" in value) && "fields" in value && Array.isArray(value.fields);
+}
+__name(isSection, "isSection");
+function notKeyed(id) {
+  return new Error(
+    `Field '${id}' is not written in the keyed form: under a key, write it without an id, as fields.shortText({ \u2026 })`
+  );
+}
+__name(notKeyed, "notKeyed");
+function compileKeyedFields(fields2) {
+  return Object.entries(fields2).map(([id, field]) => {
+    if (isSection(field)) {
+      throw new Error(
+        `'${id}' is a fieldset, and a settings group holds no Sections: write its Fields beside the others`
+      );
+    }
+    if (!isKeyedField(field)) throw notKeyed(id);
+    return compileKeyedField(id, field);
+  });
+}
+__name(compileKeyedFields, "compileKeyedFields");
+function compileKeyedMembers(members) {
+  const compiled = Object.entries(members).map(([id, member]) => {
+    if (isKeyedField(member)) return compileKeyedField(id, member);
+    if (!isSection(member)) throw notKeyed(id);
+    if (member.id !== id) {
+      throw new Error(
+        `Section '${id}' holds fieldset '${member.id}': a Section's key is its fieldset's id, so write it as ${member.id}: \u2026`
+      );
+    }
+    return member;
+  });
+  refuseAFieldIdTwice(compiled);
+  return compiled;
+}
+__name(compileKeyedMembers, "compileKeyedMembers");
+function fieldPaths(members, prefix) {
+  return members.flatMap((member) => {
+    if (isSection(member)) return fieldPaths(member.fields, `${prefix}${member.id}.`);
+    const { id } = member;
+    return [[id, `${prefix}${id}`]];
+  });
+}
+__name(fieldPaths, "fieldPaths");
+function refuseAFieldIdTwice(members) {
+  const firstPath = /* @__PURE__ */ new Map();
+  for (const [id, path] of fieldPaths(members, "")) {
+    const first = firstPath.get(id);
+    if (first !== void 0) {
+      throw new Error(
+        `Field '${id}' is declared twice, at '${first}' and at '${path}': a Section's Fields join the record it sits in, so a Field id is used once across its Sections`
+      );
+    }
+    firstPath.set(id, path);
+  }
+}
+__name(refuseAFieldIdTwice, "refuseAFieldIdTwice");
+
+// src/schema/define-content-type.ts
+function fieldset(id, config) {
+  if (Array.isArray(config.fields)) {
+    throw new Error(
+      `fieldset('${id}') takes its fields as a record, each Field under its id: the list form was removed in 0.14`
+    );
+  }
+  return {
+    id,
+    displayName: config.displayName ?? labelFromKey(id),
+    ...config.description !== void 0 && { description: config.description },
+    ...config.collapsed !== void 0 && { collapsedByDefault: config.collapsed },
+    ...config.ai !== void 0 && { ai: config.ai },
+    fields: compileKeyedMembers(config.fields)
+  };
+}
+__name(fieldset, "fieldset");
+function keyedSettings(config) {
+  return {
+    ...config.displayName !== void 0 && { displayName: config.displayName },
+    ...config.displayNamePlural !== void 0 && { displayNamePlural: config.displayNamePlural },
+    ...config.description !== void 0 && { description: config.description },
+    ...config.ai !== void 0 && { ai: config.ai },
+    ...config.displayField !== void 0 && { displayField: config.displayField },
+    ...config.accessTags !== void 0 && { accessTags: config.accessTags },
+    ...config.workflow !== void 0 && { workflow: config.workflow }
+  };
+}
+__name(keyedSettings, "keyedSettings");
+function idFormRemoved(builder, name) {
+  return new Error(
+    `${builder}('${name}', \u2026) is the id-first form, removed in 0.14: write ${builder}({ \u2026 }) under its key in defineSchema`
+  );
+}
+__name(idFormRemoved, "idFormRemoved");
+function defineContentType(config) {
+  if (typeof config === "string") throw idFormRemoved("defineContentType", config);
+  return {
+    _tag: "contentType",
+    ...keyedSettings(config),
+    // Written only when given, so a TypeScript type and its YAML twin hash alike (REL-1458)
+    ...config.hierarchical !== void 0 && { hierarchical: config.hierarchical },
+    fields: compileKeyedMembers(config.fields)
+  };
+}
+__name(defineContentType, "defineContentType");
+
+// src/schema/keyed-declarations.ts
+function isList(value) {
+  return Array.isArray(value);
+}
+__name(isList, "isList");
+function isKeyed(value, tag) {
+  return typeof value === "object" && value !== null && value._tag === tag;
+}
+__name(isKeyed, "isKeyed");
+
+// src/schema/define-role.ts
+var BUILT_IN_ROLES = ["admin", "editor", "viewer"];
+var ROLE_ACTIONS = [
+  "create",
+  "read",
+  "update",
+  "delete",
+  "publish",
+  "unpublish",
+  "duplicate",
+  "comment",
+  "approveElevated"
+];
+var BUILT_IN_ROLE_ACTIONS = {
+  admin: ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment"],
+  editor: ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment"],
+  viewer: ["read", "comment"]
+};
+function defineRole(config) {
+  if (typeof config === "string") throw idFormRemoved("defineRole", config);
+  return { ...config, _tag: "keyedRole" };
+}
+__name(defineRole, "defineRole");
+function compileKeyedRoles(roles) {
+  return Object.entries(roles).map(([id, role]) => {
+    if (!isKeyed(role, "keyedRole")) {
+      throw new Error(
+        `Role '${id}' is not written in the keyed form: under a key, write it without an id, as defineRole({ \u2026 })`
+      );
+    }
+    const { _tag: _keyed, displayName, ...config } = role;
+    return roleDefinition(id, { ...config, displayName: displayName ?? labelFromKey(id) });
+  });
+}
+__name(compileKeyedRoles, "compileKeyedRoles");
+function roleDefinition(id, config) {
+  if (!id || id.length === 0) {
+    throw new Error("Role ID is required");
+  }
+  const roleIdPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$|^[a-z][a-zA-Z0-9]*$/;
+  if (!roleIdPattern.test(id)) {
+    throw new Error(
+      `Role ID '${id}' must be kebab-case (e.g., blog-editor) or camelCase (e.g., blogEditor)`
+    );
+  }
+  if (BUILT_IN_ROLES.includes(id)) {
+    throw new Error(`Role ID '${id}' cannot use a built-in role name (admin, editor, viewer)`);
+  }
+  if (!config.displayName || config.displayName.length === 0) {
+    throw new Error("Role displayName is required");
+  }
+  const hasBaseRole = config.baseRole !== void 0;
+  const hasIncludes = Array.isArray(config.includes) && config.includes.length > 0;
+  const hasPermissions = Array.isArray(config.permissions) && config.permissions.length > 0;
+  const hasHiddenFields = config.fields !== void 0 && Array.isArray(config.fields.hidden) && config.fields.hidden.length > 0;
+  const hasReadonlyFields = config.fields !== void 0 && Array.isArray(config.fields.readonly) && config.fields.readonly.length > 0;
+  const hasFields = hasHiddenFields || hasReadonlyFields;
+  if (!hasBaseRole && !hasIncludes && !hasPermissions && !hasFields) {
+    throw new Error(
+      `Role '${id}' must have at least one of: 'baseRole', 'includes', or permissions (with tags/actions or fields)`
+    );
+  }
+  if (Array.isArray(config.permissions) && config.permissions.length > 0) {
+    for (const perm of config.permissions) {
+      if (perm.tags.length === 0) {
+        throw new Error(`Permission in role '${id}' must have at least one tag`);
+      }
+      if (perm.actions.length === 0) {
+        throw new Error(`Permission in role '${id}' must have at least one action`);
+      }
+      for (const action of perm.actions) {
+        if (!ROLE_ACTIONS.includes(action)) {
+          throw new Error(
+            `Invalid action '${action}' in role '${id}'. Valid actions: ${ROLE_ACTIONS.join(", ")}`
+          );
+        }
+      }
+    }
+  }
+  return {
+    _tag: "role",
+    id,
+    displayName: config.displayName,
+    ...config.description !== void 0 && { description: config.description },
+    ...config.baseRole !== void 0 && { baseRole: config.baseRole },
+    ...config.includes !== void 0 && { includes: config.includes },
+    ...config.permissions !== void 0 && { permissions: config.permissions },
+    ...config.fields !== void 0 && { fields: config.fields }
+  };
+}
+__name(roleDefinition, "roleDefinition");
+function isRoleDefinition(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "role";
+}
+__name(isRoleDefinition, "isRoleDefinition");
+function isBuiltInRole(roleId) {
+  return BUILT_IN_ROLES.includes(roleId);
+}
+__name(isBuiltInRole, "isBuiltInRole");
+function getBuiltInRoleActions(roleId) {
+  return BUILT_IN_ROLE_ACTIONS[roleId];
+}
+__name(getBuiltInRoleActions, "getBuiltInRoleActions");
+
+// src/schema/define-view.ts
+function defineView(config) {
+  if (typeof config === "string") throw idFormRemoved("defineView", config);
+  return { ...config, _tag: "keyedView" };
+}
+__name(defineView, "defineView");
+function compileKeyedViews(views) {
+  return Object.entries(views).map(([id, view]) => {
+    if (!isKeyed(view, "keyedView")) {
+      throw new Error(
+        `View '${id}' is not written in the keyed form: under a key, write it without an id, as defineView({ \u2026 })`
+      );
+    }
+    const { _tag: _keyed, name, ...config } = view;
+    return viewDefinition(id, { ...config, name: name ?? labelFromKey(id) });
+  });
+}
+__name(compileKeyedViews, "compileKeyedViews");
+function viewDefinition(id, config) {
+  if (!id.match(/^[a-zA-Z][a-zA-Z0-9_-]*$/)) {
+    throw new Error(
+      `View ID '${id}' must start with a letter and contain only letters, numbers, underscores, and hyphens`
+    );
+  }
+  if (!config.name || config.name.length === 0) {
+    throw new Error(`View '${id}' must have a name`);
+  }
+  if (config.metadataFields && config.metadataFields.length > 3) {
+    throw new Error(`View '${id}' can have at most 3 metadata fields`);
+  }
+  if (!config.scope?.type) {
+    throw new Error(`View '${id}' must have a valid scope`);
+  }
+  const grouped = (config.filters ?? []).findIndex(
+    (filter) => typeof filter === "object" && filter !== null && "conditions" in filter
+  );
+  if (grouped !== -1) {
+    throw new Error(
+      `View '${id}' filter ${grouped} is a filter group: a view's filters are a flat list, joined by AND. List each of its conditions as a filter of its own, or use 'isAnyOf' for an OR within one field.`
+    );
+  }
+  if (config.slug !== void 0 && !/^[a-z][a-z0-9-]*$/.test(config.slug)) {
+    throw new Error(
+      `View '${id}' slug '${config.slug}' must be lowercase, start with a letter, and contain only letters, numbers, and hyphens`
+    );
+  }
+  return {
+    _tag: "view",
+    id,
+    ...config
+  };
+}
+__name(viewDefinition, "viewDefinition");
+
 // src/schema/define-schema.ts
 function defineSchema(config) {
   if (config.contentTypes == null) {
     throw new Error("Schema must declare contentTypes (an empty object declares none)");
   }
+  refuseOneDefinitionUnderTwoKeys(config);
+  const roles = config.roles === void 0 ? void 0 : listed("roles", config.roles, compileKeyedRoles);
+  const views = config.views === void 0 ? void 0 : listed("views", config.views, compileKeyedViews);
   if (config.locales && config.locales.length > 0) {
     const defaultLocales = config.locales.filter((l) => l.default === true);
     if (defaultLocales.length === 0) {
@@ -34,9 +385,9 @@ function defineSchema(config) {
       }
     }
   }
-  if (config.roles && config.roles.length > 0) {
+  if (roles && roles.length > 0) {
     const roleIds = /* @__PURE__ */ new Set();
-    for (const role of config.roles) {
+    for (const role of roles) {
       if (roleIds.has(role.id)) {
         throw new Error(`Duplicate role ID '${role.id}'`);
       }
@@ -45,7 +396,7 @@ function defineSchema(config) {
   }
   if (config.workflow) {
     const builtInRoles = /* @__PURE__ */ new Set(["admin", "editor", "viewer"]);
-    const customRoleIds = new Set(config.roles?.map((r) => r.id) ?? []);
+    const customRoleIds = new Set(roles?.map((r) => r.id) ?? []);
     const allRoleIds = /* @__PURE__ */ new Set([...builtInRoles, ...customRoleIds]);
     for (const stage of config.workflow.stages ?? []) {
       if (stage.allowedRoles) {
@@ -82,9 +433,9 @@ function defineSchema(config) {
       }
     }
   }
-  if (config.views && config.views.length > 0) {
+  if (views && views.length > 0) {
     const viewIds = /* @__PURE__ */ new Set();
-    for (const view of config.views) {
+    for (const view of views) {
       if (viewIds.has(view.id)) {
         throw new Error(`Duplicate view ID '${view.id}'`);
       }
@@ -94,17 +445,76 @@ function defineSchema(config) {
   return {
     _tag: "schema",
     ...config.locales !== void 0 && { locales: config.locales },
-    contentTypes: config.contentTypes,
-    singletonContentTypes: config.singletonContentTypes ?? {},
-    queries: config.queries ?? {},
-    settingsGroups: config.settingsGroups,
-    ...config.assetTypes && { assetTypes: config.assetTypes },
-    ...config.roles !== void 0 && { roles: config.roles },
+    contentTypes: withKeys(config.contentTypes, "labelled"),
+    singletonContentTypes: withKeys(
+      config.singletonContentTypes ?? {},
+      "labelled"
+    ),
+    queries: withKeys(config.queries ?? {}, "unlabelled"),
+    settingsGroups: config.settingsGroups && withKeys(config.settingsGroups, "labelled"),
+    ...config.assetTypes && { assetTypes: withKeys(config.assetTypes, "labelled") },
+    // A keyed record's list is the one it compiled to, each item under its key as its id — what
+    // `RolesAsList` and `ViewsAsList` say, which is all the casts say
+    ...roles !== void 0 && { roles },
     ...config.workflow && { workflow: config.workflow },
-    ...config.views !== void 0 && { views: config.views }
+    ...views !== void 0 && { views }
   };
 }
 __name(defineSchema, "defineSchema");
+function listed(section, keyed, compile) {
+  if (Array.isArray(keyed)) {
+    throw new Error(
+      `defineSchema takes ${section} as a record, each under its id: the list form was removed in 0.14`
+    );
+  }
+  return compile(keyed);
+}
+__name(listed, "listed");
+function withKeys(items, labels) {
+  return Object.fromEntries(
+    Object.entries(items).map(([key, definition]) => {
+      const written = definition;
+      if (written.name !== void 0) return [key, definition];
+      return [
+        key,
+        {
+          ...definition,
+          name: key,
+          ...labels === "labelled" && written.displayName === void 0 && { displayName: labelFromKey(key) }
+        }
+      ];
+    })
+  );
+}
+__name(withKeys, "withKeys");
+var KEYED_SECTIONS = [
+  "contentTypes",
+  "singletonContentTypes",
+  "assetTypes",
+  "queries",
+  "settingsGroups",
+  "roles",
+  "views"
+];
+function refuseOneDefinitionUnderTwoKeys(config) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const section of KEYED_SECTIONS) {
+    const items = config[section];
+    if (items === null || typeof items !== "object" || Array.isArray(items)) continue;
+    for (const [key, definition] of Object.entries(items)) {
+      if (definition === null || typeof definition !== "object") continue;
+      const path = `${section}.${key}`;
+      const first = seen.get(definition);
+      if (first !== void 0) {
+        throw new Error(
+          `One definition is registered under two keys, '${first}' and '${path}': each key deploys a declaration of its own, so give each key its own definition`
+        );
+      }
+      seen.set(definition, path);
+    }
+  }
+}
+__name(refuseOneDefinitionUnderTwoKeys, "refuseOneDefinitionUnderTwoKeys");
 
 // src/schema/define-locale.ts
 var BCP47_PATTERN = /^[a-z]{2}(-[A-Z]{2})?$/;
@@ -178,193 +588,87 @@ function buildFallbackChain(localeCode, locales, maxDepth = 10) {
 }
 __name(buildFallbackChain, "buildFallbackChain");
 
-// src/schema/define-content-type.ts
-function fieldset(id, config) {
-  return {
-    id,
-    displayName: config.displayName,
-    description: config.description,
-    ...config.collapsedByDefault !== void 0 && {
-      collapsedByDefault: config.collapsedByDefault
-    },
-    ai: config.ai,
-    fields: config.fields
-  };
-}
-__name(fieldset, "fieldset");
-function defineContentType(name, config) {
-  return {
-    _tag: "contentType",
-    name,
-    displayName: config.displayName,
-    displayNamePlural: config.displayNamePlural,
-    description: config.description,
-    ai: config.ai,
-    displayField: config.displayField,
-    // Written only when given: it was `false` whenever not, so the same content type was one
-    // definition from YAML and another from TypeScript, with a different schemaHash (REL-1458)
-    ...config.hierarchical !== void 0 && { hierarchical: config.hierarchical },
-    ...config.accessTags !== void 0 && { accessTags: config.accessTags },
-    ...config.workflow !== void 0 && { workflow: config.workflow },
-    fields: config.fields
-  };
-}
-__name(defineContentType, "defineContentType");
-
 // src/schema/define-singleton.ts
-function defineSingletonContentType(name, config) {
+function defineSingleton(config) {
+  if (typeof config === "string") throw idFormRemoved("defineSingleton", config);
   return {
     _tag: "singletonContentType",
-    name,
-    displayName: config.displayName,
-    displayNamePlural: config.displayNamePlural,
-    description: config.description,
-    ai: config.ai,
-    displayField: config.displayField,
+    ...keyedSettings(config),
     // Written only when given, as a content type's is (REL-1458)
     ...config.hierarchical !== void 0 && { hierarchical: config.hierarchical },
-    ...config.accessTags !== void 0 && { accessTags: config.accessTags },
-    // Its config type took `workflow` and this dropped it, so a singleton's workflow never deployed
-    ...config.workflow !== void 0 && { workflow: config.workflow },
-    fields: config.fields
+    fields: compileKeyedMembers(config.fields)
   };
 }
-__name(defineSingletonContentType, "defineSingletonContentType");
-var defineSingleton = defineSingletonContentType;
+__name(defineSingleton, "defineSingleton");
 
 // src/schema/define-settings-group.ts
-function defineSettingsGroup(name, config) {
+function defineSettingsGroup(config) {
+  if (typeof config === "string") throw idFormRemoved("defineSettingsGroup", config);
   return {
     _tag: "settingsGroup",
-    name,
-    displayName: config.displayName,
-    description: config.description,
-    ai: config.ai,
+    ...config.displayName !== void 0 && { displayName: config.displayName },
+    ...config.description !== void 0 && { description: config.description },
+    ...config.ai !== void 0 && { ai: config.ai },
     ...config.accessTags !== void 0 && { accessTags: config.accessTags },
-    fields: config.fields
+    fields: compileKeyedFields(config.fields)
   };
 }
 __name(defineSettingsGroup, "defineSettingsGroup");
 
 // src/schema/define-asset-type.ts
-function defineAssetType(name, config) {
+function refuseKindKeys(config, what) {
   const kindKeys = ["image", "video", "file"].filter((k) => config[k] !== void 0);
   if (kindKeys.length === 0) {
-    throw new Error(`Asset type '${name}' must declare exactly one kind key: image, video, or file`);
+    throw new Error(`${what} must declare exactly one kind key: image, video, or file`);
   }
   if (kindKeys.length > 1) {
     throw new Error(
-      `Asset type '${name}' declares multiple kind keys (${kindKeys.join(", ")}); exactly one is allowed`
+      `${what} declares multiple kind keys (${kindKeys.join(", ")}); exactly one is allowed`
     );
   }
+}
+__name(refuseKindKeys, "refuseKindKeys");
+function defineAssetType(config) {
+  if (typeof config === "string") throw idFormRemoved("defineAssetType", config);
+  refuseKindKeys(config, "An asset type");
   return {
     _tag: "assetType",
-    name,
-    displayName: config.displayName,
-    displayNamePlural: config.displayNamePlural,
-    description: config.description,
-    ai: config.ai,
-    displayField: config.displayField,
-    // An empty list too, as a content type's and a settings group's are kept (REL-1457, REL-1458)
-    ...config.accessTags !== void 0 && { accessTags: config.accessTags },
-    ...config.workflow !== void 0 && { workflow: config.workflow },
+    ...keyedSettings(config),
     ...config.image !== void 0 && { image: config.image },
     ...config.video !== void 0 && { video: config.video },
     ...config.file !== void 0 && { file: config.file },
-    ...config.fields !== void 0 && { fields: config.fields }
+    ...config.fields !== void 0 && { fields: compileKeyedMembers(config.fields) }
   };
 }
 __name(defineAssetType, "defineAssetType");
 
-// src/schema/define-role.ts
-var BUILT_IN_ROLES = ["admin", "editor", "viewer"];
-var ROLE_ACTIONS = [
-  "create",
-  "read",
-  "update",
-  "delete",
-  "publish",
-  "unpublish",
-  "duplicate",
-  "comment",
-  "approveElevated"
-];
-var BUILT_IN_ROLE_ACTIONS = {
-  admin: ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment"],
-  editor: ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment"],
-  viewer: ["read", "comment"]
-};
-function defineRole(id, config) {
-  if (!id || id.length === 0) {
-    throw new Error("Role ID is required");
-  }
-  const roleIdPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$|^[a-z][a-zA-Z0-9]*$/;
-  if (!roleIdPattern.test(id)) {
-    throw new Error(
-      `Role ID '${id}' must be kebab-case (e.g., blog-editor) or camelCase (e.g., blogEditor)`
-    );
-  }
-  if (BUILT_IN_ROLES.includes(id)) {
-    throw new Error(`Role ID '${id}' cannot use a built-in role name (admin, editor, viewer)`);
-  }
-  if (!config.displayName || config.displayName.length === 0) {
-    throw new Error("Role displayName is required");
-  }
-  const hasBaseRole = config.baseRole !== void 0;
-  const hasIncludes = Array.isArray(config.includes) && config.includes.length > 0;
-  const hasPermissions = Array.isArray(config.permissions) && config.permissions.length > 0;
-  const hasHiddenFields = config.fields !== void 0 && Array.isArray(config.fields.hidden) && config.fields.hidden.length > 0;
-  const hasReadonlyFields = config.fields !== void 0 && Array.isArray(config.fields.readonly) && config.fields.readonly.length > 0;
-  const hasFields = hasHiddenFields || hasReadonlyFields;
-  if (!hasBaseRole && !hasIncludes && !hasPermissions && !hasFields) {
-    throw new Error(
-      `Role '${id}' must have at least one of: 'baseRole', 'includes', or permissions (with tags/actions or fields)`
-    );
-  }
-  if (Array.isArray(config.permissions) && config.permissions.length > 0) {
-    for (const perm of config.permissions) {
-      if (perm.tags.length === 0) {
-        throw new Error(`Permission in role '${id}' must have at least one tag`);
-      }
-      if (perm.actions.length === 0) {
-        throw new Error(`Permission in role '${id}' must have at least one action`);
-      }
-      for (const action of perm.actions) {
-        if (!ROLE_ACTIONS.includes(action)) {
-          throw new Error(
-            `Invalid action '${action}' in role '${id}'. Valid actions: ${ROLE_ACTIONS.join(", ")}`
-          );
-        }
-      }
-    }
-  }
-  return {
-    _tag: "role",
-    id,
-    displayName: config.displayName,
-    ...config.description !== void 0 && { description: config.description },
-    ...config.baseRole !== void 0 && { baseRole: config.baseRole },
-    ...config.includes !== void 0 && { includes: config.includes },
-    ...config.permissions !== void 0 && { permissions: config.permissions },
-    ...config.fields !== void 0 && { fields: config.fields }
-  };
-}
-__name(defineRole, "defineRole");
-function isRoleDefinition(value) {
-  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "role";
-}
-__name(isRoleDefinition, "isRoleDefinition");
-function isBuiltInRole(roleId) {
-  return BUILT_IN_ROLES.includes(roleId);
+// src/schema/define-workflow.ts
+function defineWorkflowStage(config) {
+  if (typeof config === "string") throw idFormRemoved("defineWorkflowStage", config);
+  return { ...config, _tag: "keyedWorkflowStage" };
 }
-__name(isBuiltInRole, "isBuiltInRole");
-function getBuiltInRoleActions(roleId) {
-  return BUILT_IN_ROLE_ACTIONS[roleId];
+__name(defineWorkflowStage, "defineWorkflowStage");
+function compileKeyedStages(stages) {
+  const seen = /* @__PURE__ */ new Map();
+  return Object.entries(stages).map(([id, stage]) => {
+    if (!isKeyed(stage, "keyedWorkflowStage")) {
+      throw new Error(
+        `Workflow stage '${id}' is not written in the keyed form: under a key, write it without an id, as defineWorkflowStage({ \u2026 })`
+      );
+    }
+    const first = seen.get(stage);
+    if (first !== void 0) {
+      throw new Error(
+        `One stage is registered under two keys, '${first}' and '${id}': each key is a stage of its own, so give each key its own defineWorkflowStage({ \u2026 })`
+      );
+    }
+    seen.set(stage, id);
+    const { _tag: _keyed, displayName, ...config } = stage;
+    return stageDefinition(id, { ...config, displayName: displayName ?? labelFromKey(id) });
+  });
 }
-__name(getBuiltInRoleActions, "getBuiltInRoleActions");
-
-// src/schema/define-workflow.ts
-function defineWorkflowStage(id, config) {
+__name(compileKeyedStages, "compileKeyedStages");
+function stageDefinition(id, config) {
   if (!id || id.length === 0) {
     throw new Error("Workflow stage ID is required");
   }
@@ -411,10 +715,16 @@ function defineWorkflowStage(id, config) {
     ...config.escalation !== void 0 && { escalation: config.escalation }
   };
 }
-__name(defineWorkflowStage, "defineWorkflowStage");
+__name(stageDefinition, "stageDefinition");
 function defineWorkflow(config) {
+  if (config.stages !== void 0 && isList(config.stages)) {
+    throw new Error(
+      "defineWorkflow takes its stages as a record keyed by stage id, in the order content moves through them: the list form was removed in 0.14 \u2014 write stages: { review: defineWorkflowStage({ \u2026 }) }"
+    );
+  }
+  const stages = config.stages === void 0 ? void 0 : compileKeyedStages(config.stages);
   const stageIds = /* @__PURE__ */ new Set();
-  for (const stage of config.stages ?? []) {
+  for (const stage of stages ?? []) {
     if (stageIds.has(stage.id)) {
       throw new Error(`Duplicate workflow stage ID '${stage.id}'`);
     }
@@ -423,7 +733,7 @@ function defineWorkflow(config) {
   return {
     _tag: "workflow",
     ...config.enabled !== void 0 && { enabled: config.enabled },
-    ...config.stages !== void 0 && { stages: config.stages }
+    ...stages !== void 0 && { stages }
   };
 }
 __name(defineWorkflow, "defineWorkflow");
@@ -482,45 +792,9 @@ function isFinalWorkflowStage(workflow, stageId) {
 }
 __name(isFinalWorkflowStage, "isFinalWorkflowStage");
 
-// src/schema/define-view.ts
-function defineView(id, config) {
-  if (!id.match(/^[a-zA-Z][a-zA-Z0-9_-]*$/)) {
-    throw new Error(
-      `View ID '${id}' must start with a letter and contain only letters, numbers, underscores, and hyphens`
-    );
-  }
-  if (!config.name || config.name.length === 0) {
-    throw new Error(`View '${id}' must have a name`);
-  }
-  if (config.metadataFields && config.metadataFields.length > 3) {
-    throw new Error(`View '${id}' can have at most 3 metadata fields`);
-  }
-  if (!config.scope?.type) {
-    throw new Error(`View '${id}' must have a valid scope`);
-  }
-  const grouped = (config.filters ?? []).findIndex(
-    (filter) => typeof filter === "object" && filter !== null && "conditions" in filter
-  );
-  if (grouped !== -1) {
-    throw new Error(
-      `View '${id}' filter ${grouped} is a filter group: a view's filters are a flat list, joined by AND. List each of its conditions as a filter of its own, or use 'isAnyOf' for an OR within one field.`
-    );
-  }
-  if (config.slug !== void 0 && !/^[a-z][a-z0-9-]*$/.test(config.slug)) {
-    throw new Error(
-      `View '${id}' slug '${config.slug}' must be lowercase, start with a letter, and contain only letters, numbers, and hyphens`
-    );
-  }
-  return {
-    _tag: "view",
-    id,
-    ...config
-  };
-}
-__name(defineView, "defineView");
-
 // src/schema/define-query.ts
-function defineQuery(name, config) {
+function defineQuery(config) {
+  if (typeof config === "string") throw idFormRemoved("defineQuery", config);
   if (!config.fetch && !config.aggregate && !config.search) {
     throw new Error("Query must have at least one of: fetch, aggregate or search");
   }
@@ -529,7 +803,6 @@ function defineQuery(name, config) {
   }
   return {
     _tag: "query",
-    name,
     type: config.type,
     endpoint: config.endpoint,
     description: config.description,
@@ -572,101 +845,106 @@ __export(fields_exports, {
 });
 
 // src/schema/fields/builders.ts
-function createField(id, type, options = {}) {
-  return {
-    id,
-    type,
-    ...options.config !== void 0 && { config: options.config },
-    ...options.ui !== void 0 && { ui: options.ui },
-    ...options.ai !== void 0 && { ai: options.ai },
-    // An empty list too: dropping it made a YAML field and a TypeScript one two definitions (REL-1458)
-    ...options.rules !== void 0 && { rules: options.rules },
-    ...options.localization !== void 0 && { localization: options.localization },
-    ...options.fallback !== void 0 && { fallback: options.fallback },
-    ...options.deprecated !== void 0 && { deprecated: options.deprecated }
-  };
-}
-__name(createField, "createField");
-function shortText(id, options = {}) {
-  return createField(id, "shortText", options);
+function shortText(options = {}) {
+  return keyedField("shortText", options);
 }
 __name(shortText, "shortText");
-function longText(id, options = {}) {
-  return createField(id, "longText", options);
+function longText(options = {}) {
+  return keyedField("longText", options);
 }
 __name(longText, "longText");
-function richText(id, options = {}) {
-  return createField(id, "richText", options);
+function richText(options = {}) {
+  return keyedField("richText", options);
 }
 __name(richText, "richText");
-function table(id, options = {}) {
-  return createField(id, "table", options);
+function table(options = {}) {
+  return keyedField("table", options);
 }
 __name(table, "table");
-function code(id, options = {}) {
-  return createField(id, "code", options);
+function code(options = {}) {
+  return keyedField("code", options);
 }
 __name(code, "code");
-function slug(id, options = {}) {
-  return createField(id, "slug", options);
+function slug(options = {}) {
+  return keyedField("slug", options);
 }
 __name(slug, "slug");
-function url(id, options = {}) {
-  return createField(id, "url", options);
+function url(options = {}) {
+  return keyedField("url", options);
 }
 __name(url, "url");
-function email(id, options = {}) {
-  return createField(id, "email", options);
+function email(options = {}) {
+  return keyedField("email", options);
 }
 __name(email, "email");
-function integer(id, options = {}) {
-  return createField(id, "integer", options);
+function integer(options = {}) {
+  return keyedField("integer", options);
 }
 __name(integer, "integer");
-function decimal(id, options = {}) {
-  return createField(id, "decimal", options);
+function decimal(options = {}) {
+  return keyedField("decimal", options);
 }
 __name(decimal, "decimal");
-function boolean(id, options = {}) {
-  return createField(id, "boolean", options);
+function boolean(options = {}) {
+  return keyedField("boolean", options);
 }
 __name(boolean, "boolean");
-function enumField(id, options = {}) {
-  return createField(id, "enum", options);
+function enumOptionsList(options) {
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw new Error(
+      "An enum's options in the keyed form are a value-to-label map, { draft: 'Draft', live: 'Live' }, in the order the editor shows them"
+    );
+  }
+  return Object.entries(options).map(([value, label]) => {
+    if (/^(0|[1-9]\d*)$/.test(value)) {
+      throw new Error(
+        `An enum option's value '${value}' is a whole number, which a value-to-label map cannot keep in the order it was written: JavaScript orders such keys first`
+      );
+    }
+    if (typeof label !== "string") {
+      throw new Error(`An enum option's label must be a string: '${value}' has ${String(label)}`);
+    }
+    return { value, label };
+  });
+}
+__name(enumOptionsList, "enumOptionsList");
+function enumField(options) {
+  const written = options;
+  return keyedField("enum", { ...written, options: enumOptionsList(written.options) });
 }
 __name(enumField, "enumField");
-function date(id, options = {}) {
-  return createField(id, "date", options);
+function date(options = {}) {
+  return keyedField("date", options);
 }
 __name(date, "date");
-function dateTime(id, options = {}) {
-  return createField(id, "dateTime", options);
+function dateTime(options = {}) {
+  return keyedField("dateTime", options);
 }
 __name(dateTime, "dateTime");
-function reference(id, options = {}) {
-  return createField(id, "reference", options);
+function reference(options) {
+  return keyedField("reference", options);
 }
 __name(reference, "reference");
-function tags(id, options = {}) {
-  return createField(id, "tags", options);
+function tags(options = {}) {
+  return keyedField("tags", options);
 }
 __name(tags, "tags");
-function list(id, options = {}) {
-  return createField(id, "list", options);
+function list(options = {}) {
+  return keyedField("list", options);
 }
 __name(list, "list");
-function object(id, options) {
-  return createField(id, "object", options);
+function object(options) {
+  return keyedField("object", options);
 }
 __name(object, "object");
-function json(id, options = {}) {
-  return createField(id, "json", options);
+function json(options = {}) {
+  return keyedField("json", options);
 }
 __name(json, "json");
 
 // src/schema/index.ts
 var fields = fields_exports;
 
-export { BUILT_IN_ROLES, BUILT_IN_ROLE_ACTIONS, ROLE_ACTIONS, buildFallbackChain, defineAssetType, defineContentType, defineContentTypeWorkflow, defineLocale, defineQuery, defineRole, defineSchema, defineSettingsGroup, defineSingleton, defineSingletonContentType, defineView, defineWorkflow, defineWorkflowStage, fields, fieldset, findDefaultLocale, findWorkflowStage, getActiveLocales, getBuiltInRoleActions, getFirstWorkflowStage, getLocaleCodes, getNextWorkflowStage, getWorkflowStageIds, isBuiltInRole, isFinalWorkflowStage, isLocaleDefinition, isRoleDefinition, isWorkflowDefinition, isWorkflowStageDefinition };
-//# sourceMappingURL=chunk-EW23SZPX.js.map
-//# sourceMappingURL=chunk-EW23SZPX.js.map
+export { BUILT_IN_ROLES, BUILT_IN_ROLE_ACTIONS, ROLE_ACTIONS, buildFallbackChain, defineAssetType, defineContentType, defineContentTypeWorkflow, defineLocale, defineQuery, defineRole, defineSchema, defineSettingsGroup, defineSingleton, defineView, defineWorkflow, defineWorkflowStage, fields, fieldset, findDefaultLocale, findWorkflowStage, getActiveLocales, getBuiltInRoleActions, getFirstWorkflowStage, getLocaleCodes, getNextWorkflowStage, getWorkflowStageIds, isBuiltInRole, isFinalWorkflowStage, isLocaleDefinition, isRoleDefinition, isWorkflowDefinition, isWorkflowStageDefinition };
+//# sourceMappingURL=chunk-PCFTJLEP.js.map
+//# sourceMappingURL=chunk-PCFTJLEP.js.map