@sanity/schema 5.14.0-next.14 → 5.14.0-next.16

package/lib/_internal.d.ts

@@ -1,7 +1,8 @@
 import { a as SchemaValidationResult, i as ProblemPathTypeSegment, l as Schema$1, n as ProblemPathPropertySegment, o as TypeWithProblems, r as ProblemPathSegment, s as _FIXME_, t as ProblemPath } from "./_chunks-dts/typedefs.js";
 import { SetSynchronization, SynchronizationRequest, SynchronizationResult } from "@sanity/descriptors";
 import * as _sanity_types0 from "@sanity/types";
-import { Schema, SchemaType, SchemaTypeDefinition, SchemaValidationProblem, SchemaValidationProblemGroup } from "@sanity/types";
+import { SanityDocumentLike, Schema, SchemaType, SchemaTypeDefinition, SchemaValidationProblem, SchemaValidationProblemGroup } from "@sanity/types";
+import { ComponentType, ReactNode } from "react";
 import { SchemaType as SchemaType$1 } from "groq-js";
 /** The scheduler is capable of executing work in different ways. */
 type Scheduler = {
@@ -44,6 +45,180 @@ declare function resolveSearchConfigForBaseFieldPaths(type: any, maxDepth?: numb
  */
 declare function resolveSearchConfig(type: any, maxDepth?: number): any;
 declare const ALL_FIELDS_GROUP_NAME = "all-fields";
+declare function createSchemaFromManifestTypes(schemaDef: {
+  name: string;
+  types: unknown[];
+}): Schema$1;
+interface MediaLibraryConfig {
+  enabled?: boolean;
+  libraryId?: string;
+  __internal?: {
+    frontendHost?: string;
+  };
+}
+declare const SANITY_WORKSPACE_SCHEMA_ID_PREFIX = "_.schemas";
+declare const SANITY_WORKSPACE_SCHEMA_TYPE = "system.schema";
+declare const CURRENT_WORKSPACE_SCHEMA_VERSION = "2025-05-01";
+type ManifestSerializable = string | number | boolean | {
+  [k: string]: ManifestSerializable;
+} | ManifestSerializable[];
+interface CreateManifest {
+  version: number;
+  createdAt: string;
+  workspaces: ManifestWorkspaceFile[];
+  studioVersion: string | null;
+}
+interface ManifestWorkspaceFile extends Omit<CreateWorkspaceManifest, 'schema' | 'tools'> {
+  schema: string;
+  tools: string;
+}
+interface CreateWorkspaceManifest {
+  name: string;
+  title?: string;
+  subtitle?: string;
+  basePath: string;
+  dataset: string;
+  projectId: string;
+  mediaLibrary?: MediaLibraryConfig;
+  schema: ManifestSchemaType[];
+  tools: ManifestTool[];
+  /**
+   * returns undefined in the case of the icon not being able to be stringified
+   */
+  icon: string | undefined;
+}
+interface ManifestSchemaType {
+  type: string;
+  name: string;
+  title?: string;
+  deprecated?: {
+    reason: string;
+  };
+  readOnly?: boolean | 'conditional';
+  hidden?: boolean | 'conditional';
+  validation?: ManifestValidationGroup[];
+  fields?: ManifestField[];
+  to?: ManifestReferenceMember[];
+  of?: ManifestArrayMember[];
+  preview?: {
+    select: Record<string, string>;
+  };
+  fieldsets?: ManifestFieldset[];
+  options?: Record<string, ManifestSerializable>;
+  marks?: {
+    annotations?: ManifestArrayMember[];
+    decorators?: ManifestTitledValue[];
+  };
+  lists?: ManifestTitledValue[];
+  styles?: ManifestTitledValue[];
+}
+interface ManifestFieldset {
+  name: string;
+  title?: string;
+  [index: string]: ManifestSerializable | undefined;
+}
+interface ManifestTitledValue {
+  value: string;
+  title?: string;
+}
+type ManifestField = ManifestSchemaType & {
+  fieldset?: string;
+};
+type ManifestArrayMember = Omit<ManifestSchemaType, 'name'> & {
+  name?: string;
+};
+type ManifestReferenceMember = Omit<ManifestSchemaType, 'name'> & {
+  name?: string;
+};
+interface ManifestValidationGroup {
+  rules: ManifestValidationRule[];
+  message?: string;
+  level?: 'error' | 'warning' | 'info';
+}
+type ManifestValidationRule = {
+  flag: string;
+  constraint?: ManifestSerializable;
+  [index: string]: ManifestSerializable | undefined;
+};
+interface ManifestTool {
+  name: string;
+  title: string;
+  /**
+   * returns undefined in the case of the icon not being able to be stringified
+   */
+  icon: string | undefined;
+  type: string | null;
+}
+type DefaultWorkspaceSchemaId = `${typeof SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.${string}`;
+type PrefixedWorkspaceSchemaId = `${DefaultWorkspaceSchemaId}.${string}`;
+type WorkspaceSchemaId = DefaultWorkspaceSchemaId | PrefixedWorkspaceSchemaId;
+interface StoredWorkspaceSchema extends SanityDocumentLike {
+  _type: typeof SANITY_WORKSPACE_SCHEMA_TYPE;
+  _id: WorkspaceSchemaId;
+  version: typeof CURRENT_WORKSPACE_SCHEMA_VERSION | undefined;
+  tag?: string;
+  workspace: {
+    name: string;
+    title?: string;
+  };
+  /**
+   * The API expects JSON coming in, but will store a string to save on attribute paths.
+   * Consumers must use JSON.parse on the value, put we deploy to the API using ManifestSchemaType[]
+   */
+  schema: string | ManifestSchemaType[];
+}
+interface ManifestWorkspaceInput {
+  name: string;
+  title?: string;
+  subtitle?: string;
+  basePath: string;
+  projectId: string;
+  dataset: string;
+  icon?: ComponentType | ReactNode;
+  mediaLibrary?: MediaLibraryConfig;
+  schema: Schema;
+  tools: ManifestToolInput[];
+}
+interface ManifestToolInput {
+  title: string;
+  name: string;
+  icon?: ComponentType | ReactNode;
+  __internalApplicationType?: string;
+}
+type IconResolver = (props: {
+  icon?: ComponentType | ReactNode;
+  title: string;
+  subtitle?: string;
+}) => string | undefined | Promise<string | undefined>;
+declare function extractCreateWorkspaceManifest(workspace: ManifestWorkspaceInput, iconResolver?: IconResolver): Promise<CreateWorkspaceManifest>;
+/**
+ * Extracts all serializable properties from userland schema types,
+ * so they best-effort can be used as definitions for Schema.compile
+ . */
+declare function extractManifestSchemaTypes(schema: Schema): ManifestSchemaType[];
+declare const validForNamesChars = "a-zA-Z0-9_-";
+declare const validForNamesPattern: RegExp;
+declare function getWorkspaceSchemaId(args: {
+  workspaceName: string;
+  tag?: string;
+}): {
+  safeBaseId: DefaultWorkspaceSchemaId;
+  safeTaggedId: WorkspaceSchemaId;
+  idWarning: string | undefined;
+};
+interface ParsedWorkspaceSchemaId {
+  schemaId: string;
+  workspace: string;
+}
+declare function parseWorkspaceSchemaId(id: string, errors: string[]): ParsedWorkspaceSchemaId | undefined;
+declare function createStoredWorkspaceSchemaPayload(args: {
+  workspace: {
+    name: string;
+    title?: string;
+  };
+  schema: ManifestSchemaType[];
+  tag?: string;
+}): Omit<StoredWorkspaceSchema, '_id' | '_type'>;
 declare const builtinTypes: ({
   name: string;
   title: string;
@@ -240,10 +415,6 @@ declare const builtinTypes: ({
     readOnly: boolean;
   })[];
 })[];
-declare function createSchemaFromManifestTypes(schemaDef: {
-  name: string;
-  types: unknown[];
-}): Schema$1;
 interface ExtractSchemaOptions {
   enforceRequiredFields?: boolean;
 }
@@ -311,4 +482,4 @@ declare class ValidationError extends Error {
   problems: SchemaValidationProblemGroup[];
   constructor(problems: SchemaValidationProblemGroup[]);
 }
-export { ALL_FIELDS_GROUP_NAME, DEFAULT_MAX_FIELD_DEPTH, DescriptorConverter, type _FIXME_ as FIXME, type SchemaValidationResult as Problem, type SchemaValidationResult as ValidationResult, type ProblemPath, type ProblemPathPropertySegment, type ProblemPathSegment, type ProblemPathTypeSegment, SchemaSynchronizationRequest, SchemaSynchronizationResult, type TypeWithProblems, ValidationError, builtinTypes, createSchemaFromManifestTypes, extractSchema, groupProblems, isActionEnabled, processSchemaSynchronization, resolveSearchConfig, resolveSearchConfigForBaseFieldPaths, validateMediaLibraryAssetAspect, validateSchema };
+export { ALL_FIELDS_GROUP_NAME, type CreateManifest, type CreateWorkspaceManifest, DEFAULT_MAX_FIELD_DEPTH, type DefaultWorkspaceSchemaId, DescriptorConverter, type _FIXME_ as FIXME, type IconResolver, type ManifestSchemaType, type ManifestWorkspaceFile, type ParsedWorkspaceSchemaId, type SchemaValidationResult as Problem, type SchemaValidationResult as ValidationResult, type ProblemPath, type ProblemPathPropertySegment, type ProblemPathSegment, type ProblemPathTypeSegment, SchemaSynchronizationRequest, SchemaSynchronizationResult, type StoredWorkspaceSchema, type TypeWithProblems, ValidationError, type WorkspaceSchemaId, builtinTypes, createSchemaFromManifestTypes, createStoredWorkspaceSchemaPayload, extractCreateWorkspaceManifest, extractManifestSchemaTypes, extractSchema, getWorkspaceSchemaId, groupProblems, isActionEnabled, parseWorkspaceSchemaId, processSchemaSynchronization, resolveSearchConfig, resolveSearchConfigForBaseFieldPaths, validForNamesChars, validForNamesPattern, validateMediaLibraryAssetAspect, validateSchema };

package/lib/_internal.js

@@ -14,6 +14,7 @@ import isPlainObject from "lodash-es/isPlainObject.js";
 import omit from "lodash-es/omit.js";
 import leven from "leven";
 import inspect from "object-inspect";
+import startCase from "lodash-es/startCase.js";
 import { createReferenceTypeNode } from "groq-js";
 const MAX_IDLE_WORK = 8.333333333333334;
 class IdleScheduler {
@@ -2350,6 +2351,405 @@ function stringToRegExp(str) {
   const match = str.match(/^\/(.*)\/([gimuy]*)$/);
   return match ? new RegExp(match[1], match[2]) : new RegExp(str);
 }
+const DEFAULT_IMAGE_FIELDS = ["asset", "hotspot", "crop", "media"], DEFAULT_FILE_FIELDS = ["asset", "media"], DEFAULT_GEOPOINT_FIELDS = ["lat", "lng", "alt"], DEFAULT_SLUG_FIELDS = ["current", "source"];
+function getCustomFields(type) {
+  const fields = type.fieldsets ? type.fieldsets.flatMap((fs) => fs.single ? fs.field : fs.fields.map((field) => ({
+    ...field,
+    fieldset: fs.name
+  }))) : type.fields;
+  return isType$1(type, "block") ? [] : isType$1(type, "slug") ? fields.filter((f) => !DEFAULT_SLUG_FIELDS.includes(f.name)) : isType$1(type, "geopoint") ? fields.filter((f) => !DEFAULT_GEOPOINT_FIELDS.includes(f.name)) : isType$1(type, "image") ? fields.filter((f) => !DEFAULT_IMAGE_FIELDS.includes(f.name)) : isType$1(type, "file") ? fields.filter((f) => !DEFAULT_FILE_FIELDS.includes(f.name)) : fields;
+}
+function isReference(type) {
+  return isType$1(type, "reference");
+}
+function isCrossDatasetReference(type) {
+  return isType$1(type, "crossDatasetReference");
+}
+function isGlobalDocumentReference(type) {
+  return isType$1(type, "globalDocumentReference");
+}
+function isObjectField(maybeOjectField) {
+  return typeof maybeOjectField == "object" && maybeOjectField !== null && "name" in maybeOjectField;
+}
+function isCustomized(maybeCustomized) {
+  const internalOwnProps = getSchemaTypeInternalOwnProps(maybeCustomized);
+  return isObjectField(maybeCustomized) && !isReference(maybeCustomized) && !isCrossDatasetReference(maybeCustomized) && !isGlobalDocumentReference(maybeCustomized) && "fields" in maybeCustomized && Array.isArray(maybeCustomized.fields) && // needed to differentiate inline, named array object types from globally defined types
+  // we only consider it customized if the _definition_ has fields declared
+  // this holds for all customizable object-like types: object, document, image and file
+  internalOwnProps?.fields ? !!getCustomFields(maybeCustomized).length : !1;
+}
+function isType$1(schemaType, typeName) {
+  return schemaType.name === typeName ? !0 : schemaType.type ? isType$1(schemaType.type, typeName) : !1;
+}
+function isDefined(value) {
+  return value != null;
+}
+function isRecord(value) {
+  return !!value && typeof value == "object";
+}
+function isPrimitive(value) {
+  return isString(value) || isBoolean(value) || isNumber(value);
+}
+function isString(value) {
+  return typeof value == "string";
+}
+function isNumber(value) {
+  return typeof value == "number";
+}
+function isBoolean(value) {
+  return typeof value == "boolean";
+}
+function getSchemaTypeInternalOwnProps(type) {
+  return type?._internal_ownProps;
+}
+function getDefinedTypeName(type) {
+  return getSchemaTypeInternalOwnProps(type)?.type;
+}
+const MAX_CUSTOM_PROPERTY_DEPTH = 5, noopIconResolver = () => {
+};
+async function extractCreateWorkspaceManifest(workspace, iconResolver = noopIconResolver) {
+  const serializedSchema = extractManifestSchemaTypes(workspace.schema), serializedTools = await extractManifestTools(workspace.tools, iconResolver);
+  return {
+    name: workspace.name,
+    title: workspace.title,
+    subtitle: workspace.subtitle,
+    basePath: workspace.basePath,
+    projectId: workspace.projectId,
+    dataset: workspace.dataset,
+    icon: await iconResolver({
+      icon: workspace.icon,
+      title: workspace.title ?? workspace.name,
+      subtitle: workspace.subtitle
+    }),
+    mediaLibrary: workspace.mediaLibrary,
+    schema: serializedSchema,
+    tools: serializedTools
+  };
+}
+function extractManifestSchemaTypes(schema) {
+  const typeNames = schema.getTypeNames(), studioDefaultTypeNames = Schema.compile({
+    name: "default",
+    types: builtinTypes
+  }).getTypeNames();
+  return typeNames.filter((typeName) => !studioDefaultTypeNames.includes(typeName)).map((typeName) => schema.get(typeName)).filter((type) => typeof type < "u").map((type) => transformType(type));
+}
+function transformCommonTypeFields(type, typeName, context) {
+  const arrayProps = typeName === "array" && type.jsonType === "array" ? transformArrayMember(type) : {}, referenceProps = isReference(type) ? transformReference(type) : {}, crossDatasetRefProps = isCrossDatasetReference(type) ? transformCrossDatasetReference(type) : {}, globalRefProps = isGlobalDocumentReference(type) ? transformGlobalDocumentReference(type) : {}, objectFields = type.jsonType === "object" && type.type && isCustomized(type) ? {
+    fields: getCustomFields(type).map((objectField) => transformField(objectField))
+  } : {};
+  return {
+    ...retainCustomTypeProps(type),
+    ...transformValidation(type.validation),
+    ...ensureString("description", type.description),
+    ...objectFields,
+    ...arrayProps,
+    ...referenceProps,
+    ...crossDatasetRefProps,
+    ...globalRefProps,
+    ...ensureConditional("readOnly", type.readOnly),
+    ...ensureConditional("hidden", type.hidden),
+    ...transformFieldsets(type),
+    // fieldset prop gets instrumented via getCustomFields
+    ...ensureString("fieldset", type.fieldset),
+    ...transformBlockType(type)
+  };
+}
+function transformFieldsets(type) {
+  if (type.jsonType !== "object")
+    return {};
+  const fieldsets = type.fieldsets?.filter((fs) => !fs.single).map((fs) => {
+    const options = isRecord(fs.options) ? { options: retainSerializableProps(fs.options) } : {};
+    return {
+      name: fs.name,
+      ...ensureCustomTitle(fs.name, fs.title),
+      ...ensureString("description", fs.description),
+      ...ensureConditional("readOnly", fs.readOnly),
+      ...ensureConditional("hidden", fs.hidden),
+      ...options
+    };
+  });
+  return fieldsets?.length ? { fieldsets } : {};
+}
+function transformType(type, context) {
+  const typeName = type.type ? type.type.name : type.jsonType;
+  return {
+    ...transformCommonTypeFields(type, typeName),
+    name: type.name,
+    type: typeName,
+    ...ensureCustomTitle(type.name, type.title)
+  };
+}
+function retainCustomTypeProps(type) {
+  const manuallySerializedFields = [
+    //explicitly added
+    "name",
+    "title",
+    "description",
+    "readOnly",
+    "hidden",
+    "validation",
+    "fieldsets",
+    "fields",
+    "to",
+    "of",
+    // not serialized
+    "type",
+    "jsonType",
+    "__experimental_actions",
+    "__experimental_formPreviewTitle",
+    "__experimental_omnisearch_visibility",
+    "__experimental_search",
+    "components",
+    "icon",
+    "orderings",
+    "preview",
+    "groups",
+    //only exists on fields
+    "group"
+    // we know about these, but let them be generically handled
+    // deprecated
+    // rows (from text)
+    // initialValue
+    // options
+    // crossDatasetReference props
+  ], typeWithoutManuallyHandledFields = Object.fromEntries(
+    Object.entries(type).filter(
+      ([key]) => !manuallySerializedFields.includes(key)
+    )
+  );
+  return retainSerializableProps(typeWithoutManuallyHandledFields);
+}
+function retainSerializableProps(maybeSerializable, depth = 0) {
+  if (!(depth > MAX_CUSTOM_PROPERTY_DEPTH) && isDefined(maybeSerializable)) {
+    if (isPrimitive(maybeSerializable))
+      return maybeSerializable === "" ? void 0 : maybeSerializable;
+    if (maybeSerializable instanceof RegExp)
+      return maybeSerializable.toString();
+    if (Array.isArray(maybeSerializable)) {
+      const arrayItems = maybeSerializable.map((item) => retainSerializableProps(item, depth + 1)).filter((item) => isDefined(item));
+      return arrayItems.length ? arrayItems : void 0;
+    }
+    if (isRecord(maybeSerializable)) {
+      const serializableEntries = Object.entries(maybeSerializable).map(([key, value]) => [key, retainSerializableProps(value, depth + 1)]).filter(([, value]) => isDefined(value));
+      return serializableEntries.length ? Object.fromEntries(serializableEntries) : void 0;
+    }
+  }
+}
+function transformField(field, context) {
+  const fieldType = field.type, typeName = getDefinedTypeName(fieldType) ?? fieldType.name;
+  return {
+    ...transformCommonTypeFields(fieldType, typeName),
+    name: field.name,
+    type: typeName,
+    ...ensureCustomTitle(field.name, fieldType.title),
+    // this prop gets added synthetically via getCustomFields
+    ...ensureString("fieldset", field.fieldset)
+  };
+}
+function transformArrayMember(arrayMember, context) {
+  return {
+    of: arrayMember.of.map((type) => {
+      const typeName = getDefinedTypeName(type) ?? type.name;
+      return {
+        ...transformCommonTypeFields(type, typeName),
+        type: typeName,
+        ...typeName === type.name ? {} : { name: type.name },
+        ...ensureCustomTitle(type.name, type.title)
+      };
+    })
+  };
+}
+function transformReference(reference2) {
+  return {
+    to: (reference2.to ?? []).map((type) => ({
+      ...retainCustomTypeProps(type),
+      type: type.name
+    }))
+  };
+}
+function transformCrossDatasetReference(reference2) {
+  return {
+    to: (reference2.to ?? []).map((crossDataset) => {
+      const preview = crossDataset.preview?.select ? { preview: { select: crossDataset.preview.select } } : {};
+      return {
+        type: crossDataset.type,
+        ...ensureCustomTitle(crossDataset.type, crossDataset.title),
+        ...preview
+      };
+    })
+  };
+}
+function transformGlobalDocumentReference(reference2) {
+  return {
+    to: (reference2.to ?? []).map((crossDataset) => {
+      const preview = crossDataset.preview?.select ? { preview: { select: crossDataset.preview.select } } : {};
+      return {
+        type: crossDataset.type,
+        ...ensureCustomTitle(crossDataset.type, crossDataset.title),
+        ...preview
+      };
+    })
+  };
+}
+const transformTypeValidationRule = (rule) => ({
+  ...rule,
+  constraint: "constraint" in rule && (typeof rule.constraint == "string" ? rule.constraint.toLowerCase() : retainSerializableProps(rule.constraint))
+}), validationRuleTransformers = {
+  type: transformTypeValidationRule
+};
+function transformValidation(validation) {
+  const validationArray = (Array.isArray(validation) ? validation : [validation]).filter(
+    (value) => typeof value == "object" && "_type" in value
+  ), disallowedFlags = ["type"], disallowedConstraintTypes = [Rule.FIELD_REF], serializedValidation = validationArray.map(({ _rules, _message, _level }) => {
+    const message = typeof _message == "string" ? { message: _message } : {};
+    return {
+      rules: _rules.filter((rule) => {
+        if (!("constraint" in rule))
+          return !1;
+        const { flag, constraint } = rule;
+        return disallowedFlags.includes(flag) ? !1 : !(typeof constraint == "object" && "type" in constraint && disallowedConstraintTypes.includes(constraint.type));
+      }).reduce((rules, rule) => {
+        const transformedRule = (validationRuleTransformers[rule.flag] ?? ((spec) => retainSerializableProps(spec)))(rule);
+        return transformedRule ? [...rules, transformedRule] : rules;
+      }, []),
+      level: _level,
+      ...message
+    };
+  }).filter((group) => !!group.rules.length);
+  return serializedValidation.length ? { validation: serializedValidation } : {};
+}
+function ensureCustomTitle(typeName, value) {
+  const titleObject = ensureString("title", value), defaultTitle = startCase(typeName);
+  return titleObject.title === defaultTitle ? {} : titleObject;
+}
+function ensureString(key, value) {
+  return typeof value == "string" ? {
+    [key]: value
+  } : {};
+}
+function ensureConditional(key, value) {
+  return typeof value == "boolean" ? {
+    [key]: value
+  } : typeof value == "function" ? {
+    [key]: "conditional"
+  } : {};
+}
+function transformBlockType(blockType, context) {
+  if (blockType.jsonType !== "object" || !isType$1(blockType, "block"))
+    return {};
+  const childrenField = blockType.fields?.find((field) => field.name === "children");
+  if (!childrenField)
+    return {};
+  const ofType = childrenField.type.of;
+  if (!ofType)
+    return {};
+  const spanType = ofType.find((memberType) => memberType.name === "span");
+  if (!spanType)
+    return {};
+  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [];
+  return {
+    marks: {
+      annotations: spanType.annotations.map((t) => transformType(t)),
+      decorators: resolveEnabledDecorators(spanType)
+    },
+    lists: resolveEnabledListItems(blockType),
+    styles: resolveEnabledStyles(blockType),
+    of: inlineObjectTypes.map((t) => transformType(t))
+  };
+}
+function resolveEnabledStyles(blockType) {
+  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  return resolveTitleValueArray(styleField?.type?.options?.list);
+}
+function resolveEnabledDecorators(spanType) {
+  return "decorators" in spanType ? resolveTitleValueArray(spanType.decorators) : void 0;
+}
+function resolveEnabledListItems(blockType) {
+  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  return resolveTitleValueArray(listField?.type?.options?.list);
+}
+function resolveTitleValueArray(possibleArray) {
+  if (!possibleArray || !Array.isArray(possibleArray))
+    return;
+  const titledValues = possibleArray.filter(
+    (d) => isRecord(d) && !!d.value && isString(d.value)
+  ).map((item) => ({
+    value: item.value,
+    ...ensureString("title", item.title)
+  }));
+  if (titledValues?.length)
+    return titledValues;
+}
+const extractManifestTools = async (tools, iconResolver = noopIconResolver) => Promise.all(
+  tools.map(async (tool) => {
+    const { title, name, icon, __internalApplicationType: type } = tool;
+    return {
+      title,
+      name,
+      type: type || null,
+      icon: await iconResolver({
+        icon,
+        title
+      })
+    };
+  })
+), SANITY_WORKSPACE_SCHEMA_ID_PREFIX = "_.schemas", CURRENT_WORKSPACE_SCHEMA_VERSION = "2025-05-01", validForNamesChars = "a-zA-Z0-9_-", validForNamesPattern = new RegExp(`^[${validForNamesChars}]+$`, "g"), validForIdChars = "a-zA-Z0-9._-", validForIdPattern = new RegExp(`^[${validForIdChars}]+$`, "g"), requiredInId = SANITY_WORKSPACE_SCHEMA_ID_PREFIX.replace(/[.]/g, "\\."), idPatternString = `^${requiredInId}\\.([${validForNamesChars}]+)`, baseIdPattern = new RegExp(`${idPatternString}$`), taggedIdPattern = new RegExp(`${idPatternString}\\.tag\\.([${validForNamesChars}]+)$`);
+function getWorkspaceSchemaId(args) {
+  const { workspaceName: rawWorkspaceName, tag } = args;
+  let workspaceName = rawWorkspaceName, idWarning;
+  workspaceName.match(validForNamesPattern) || (workspaceName = workspaceName.replace(new RegExp(`[^${validForNamesChars}]`, "g"), "_"), idWarning = [
+    `Workspace "${rawWorkspaceName}" contains characters unsupported by schema _id [${validForNamesChars}], they will be replaced with _.`,
+    "This could lead duplicate schema ids: consider renaming your workspace."
+  ].join(`
+`));
+  const safeBaseId = `${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.${workspaceName}`;
+  return {
+    safeBaseId,
+    safeTaggedId: `${safeBaseId}${tag ? `.tag.${tag}` : ""}`,
+    idWarning
+  };
+}
+function parseWorkspaceSchemaId(id, errors) {
+  const trimmedId = id.trim();
+  if (!trimmedId.match(validForIdPattern)) {
+    errors.push(`id can only contain characters in [${validForIdChars}] but found: "${trimmedId}"`);
+    return;
+  }
+  if (trimmedId.startsWith("-")) {
+    errors.push(`id cannot start with - (dash) but found: "${trimmedId}"`);
+    return;
+  }
+  if (trimmedId.match(/\.\./g)) {
+    errors.push(`id cannot have consecutive . (period) characters, but found: "${trimmedId}"`);
+    return;
+  }
+  const [, workspace] = trimmedId.match(taggedIdPattern) ?? trimmedId.match(baseIdPattern) ?? [];
+  if (!workspace) {
+    errors.push(
+      [
+        `id must either match ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName> `,
+        `or ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName>.tag.<tag> but found: "${trimmedId}". `,
+        `Note that workspace name characters not in [${validForNamesChars}] has to be replaced with _ for schema id.`
+      ].join("")
+    );
+    return;
+  }
+  return {
+    schemaId: trimmedId,
+    workspace
+  };
+}
+function createStoredWorkspaceSchemaPayload(args) {
+  return {
+    version: CURRENT_WORKSPACE_SCHEMA_VERSION,
+    tag: args.tag,
+    workspace: {
+      name: args.workspace.name,
+      title: args.workspace.title
+    },
+    schema: args.schema
+  };
+}
 const documentDefaultFields = (typeName) => ({
   _id: {
     type: "objectAttribute",
@@ -2950,12 +3350,19 @@ export {
   ValidationError,
   builtinTypes,
   createSchemaFromManifestTypes,
+  createStoredWorkspaceSchemaPayload,
+  extractCreateWorkspaceManifest,
+  extractManifestSchemaTypes,
   extractSchema,
+  getWorkspaceSchemaId,
   groupProblems,
   isActionEnabled,
+  parseWorkspaceSchemaId,
   processSchemaSynchronization,
   resolveSearchConfig,
   resolveSearchConfigForBaseFieldPaths,
+  validForNamesChars,
+  validForNamesPattern,
   validateMediaLibraryAssetAspect,
   validateSchema
 };