@webstudio-is/sdk 0.274.5 → 0.276.0

package/lib/index.js

@@ -185,6 +185,7 @@ var projectMeta = z2.object({
   contactEmail: z2.string().optional(),
   faviconAssetId: z2.string().optional(),
   code: z2.string().optional(),
+  agentInstructions: z2.string().optional(),
   auth: z2.string().optional()
 });
 var projectNewRedirectPath = z2.string().min(1, "Path is required").refine((data) => {
@@ -346,12 +347,29 @@ var pages = z2.object({
 
 // src/schema/instances.ts
 import { z as z3 } from "zod";
+var textChildValue = z3.string();
 var textChild = z3.object({
   type: z3.literal("text"),
-  value: z3.string(),
+  value: textChildValue,
   placeholder: z3.boolean().optional()
 });
 var instanceId = z3.string();
+var instanceComponent = z3.string().min(1);
+var instanceTag = z3.string().min(1, "Tag cannot be empty").describe(
+  "Optional HTML tag override for component rendering. Omit for component defaults; never pass an empty string."
+);
+var instanceAttributes = z3.object({
+  component: instanceComponent,
+  tag: instanceTag.optional(),
+  label: z3.string().optional()
+});
+var instanceCreateInput = instanceAttributes.partial({
+  component: true
+});
+var instanceFilterInput = instanceAttributes.pick({
+  component: true,
+  tag: true
+}).partial();
 var idChild = z3.object({
   type: z3.literal("id"),
   value: instanceId
@@ -364,9 +382,9 @@ var instanceChild = z3.union([idChild, textChild, expressionChild]);
 var instance = z3.object({
   type: z3.literal("instance"),
   id: instanceId,
-  component: z3.string(),
-  tag: z3.string().optional(),
-  label: z3.string().optional(),
+  component: instanceAttributes.shape.component,
+  tag: instanceAttributes.shape.tag,
+  label: instanceAttributes.shape.label,
   children: z3.array(instanceChild)
 });
 var instances = z3.map(instanceId, instance);
@@ -394,8 +412,8 @@ var dataSourceVariableValue = z4.union([
   }),
   z4.object({
     type: z4.literal("json"),
-    value: z4.unknown()
-  })
+    value: z4.unknown().optional()
+  }).transform((value) => ({ ...value, value: value.value ?? null }))
 ]);
 var dataSource = z4.union([
   z4.object({
@@ -461,6 +479,7 @@ var resource = z5.object({
 });
 var resourceRequest = z5.object({
   name: z5.string(),
+  control: z5.optional(z5.union([z5.literal("system"), z5.literal("graphql")])),
   method,
   url: z5.string(),
   searchParams: z5.array(
@@ -571,7 +590,7 @@ var insetUnitValue = z6.union([
     value: z6.literal("auto")
   })
 ]);
-var keyframeStyles = z6.record(styleValue);
+var keyframeStyles = z6.record(z6.string(), styleValue);
 var animationKeyframe = z6.object({
   offset: z6.number().optional(),
   styles: keyframeStyles
@@ -910,7 +929,11 @@ var code = z14.object({
   ...common,
   control: z14.literal("code"),
   type: z14.literal("string"),
-  language: z14.union([z14.literal("html"), z14.literal("markdown")]),
+  language: z14.union([
+    z14.literal("html"),
+    z14.literal("json"),
+    z14.literal("markdown")
+  ]),
   defaultValue: z14.string().optional()
 });
 var codeText = z14.object({
@@ -919,6 +942,12 @@ var codeText = z14.object({
   type: z14.literal("string"),
   defaultValue: z14.string().optional()
 });
+var jsonCode = z14.object({
+  ...common,
+  control: z14.literal("json-code"),
+  type: z14.literal("string"),
+  defaultValue: z14.string().optional()
+});
 var color = z14.object({
   ...common,
   control: z14.literal("color"),
@@ -1034,6 +1063,7 @@ var propMeta = z14.union([
   resource2,
   code,
   codeText,
+  jsonCode,
   color,
   boolean,
   radio,
@@ -1076,6 +1106,13 @@ var componentCategories = [
   "hidden",
   "internal"
 ];
+var normalizeComponentCategory = (category) => {
+  return category ?? "hidden";
+};
+var shouldFilterComponentCategory = (category) => {
+  const normalized = normalizeComponentCategory(category);
+  return normalized === "hidden" || normalized === "internal";
+};
 var componentState = z15.object({
   selector: z15.string(),
   label: z15.string()
@@ -1106,13 +1143,14 @@ var wsComponentMeta = z15.object({
   indexWithinAncestor: z15.optional(z15.string()),
   label: z15.optional(z15.string()),
   description: z15.string().optional(),
+  deprecated: z15.boolean().optional(),
   icon: z15.string().optional(),
   presetStyle: z15.optional(z15.record(z15.string(), z15.array(presetStyleDecl))),
   states: z15.optional(z15.array(componentState)),
   order: z15.number().optional(),
   // properties and html attributes that will be always visible in properties panel
   initialProps: z15.array(z15.string()).optional(),
-  props: z15.record(propMeta).optional()
+  props: z15.record(z15.string(), propMeta).optional()
 });
 
 // src/assets.ts
@@ -1787,6 +1825,289 @@ var summary = [
   { property: "box-sizing", value: { type: "keyword", value: "border-box" } }
 ];
 
+// src/json-ld-utils.ts
+var isJsonObject = (value) => typeof value === "object" && value !== null && Array.isArray(value) === false;
+var appendJsonPath = (path, key) => typeof key === "number" ? `${path}[${key}]` : /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+var getJsonLdTypes = (value) => typeof value === "string" ? [value] : Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+
+// src/json-ld.ts
+var pushKeywordTypeError = (diagnostics, path, message) => {
+  diagnostics.push({
+    severity: "error",
+    code: "invalid-keyword-value",
+    path,
+    message
+  });
+};
+var escapeJsonLdScriptText = (value) => value.replace(/</g, "\\u003c");
+var validateContextTermDefinition = (definition, path, diagnostics) => {
+  if (definition === null || typeof definition === "string" || isJsonObject(definition)) {
+    if (isJsonObject(definition) && definition["@context"] !== void 0) {
+      validateContext(
+        definition["@context"],
+        appendJsonPath(path, "@context"),
+        diagnostics
+      );
+    }
+    return;
+  }
+  diagnostics.push({
+    severity: "error",
+    code: "invalid-context",
+    path,
+    message: "JSON-LD context terms must map to a string, object, or null."
+  });
+};
+var validateContext = (context, path, diagnostics) => {
+  if (context === null || typeof context === "string") {
+    return;
+  }
+  if (Array.isArray(context)) {
+    context.forEach(
+      (item, index) => validateContext(item, appendJsonPath(path, index), diagnostics)
+    );
+    return;
+  }
+  if (isJsonObject(context) === false) {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path,
+      message: "@context must be a string, object, array of contexts, or null."
+    });
+    return;
+  }
+  for (const keyword of ["@base", "@vocab", "@language"]) {
+    if (context[keyword] !== void 0 && context[keyword] !== null && typeof context[keyword] !== "string") {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid-context",
+        path: appendJsonPath(path, keyword),
+        message: `${keyword} must be a string or null.`
+      });
+    }
+  }
+  if (context["@direction"] !== void 0 && context["@direction"] !== null && context["@direction"] !== "ltr" && context["@direction"] !== "rtl") {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path: appendJsonPath(path, "@direction"),
+      message: '@direction must be "ltr", "rtl", or null.'
+    });
+  }
+  if (context["@propagate"] !== void 0 && typeof context["@propagate"] !== "boolean") {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path: appendJsonPath(path, "@propagate"),
+      message: "@propagate must be a boolean."
+    });
+  }
+  if (context["@version"] !== void 0 && context["@version"] !== 1.1) {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path: appendJsonPath(path, "@version"),
+      message: "@version must be 1.1."
+    });
+  }
+  for (const [term, definition] of Object.entries(context)) {
+    if (term.startsWith("@")) {
+      continue;
+    }
+    validateContextTermDefinition(
+      definition,
+      appendJsonPath(path, term),
+      diagnostics
+    );
+  }
+};
+var validateNestedValues = (value, path, diagnostics) => {
+  if (isJsonObject(value)) {
+    validateNode(value, path, diagnostics);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      if (isJsonObject(item) || Array.isArray(item)) {
+        validateNestedValues(item, appendJsonPath(path, index), diagnostics);
+      }
+    });
+  }
+};
+var validateNode = (value, path, diagnostics) => {
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => validateNode(item, appendJsonPath(path, index), diagnostics)
+    );
+    return;
+  }
+  if (isJsonObject(value) === false) {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-root",
+      path,
+      message: "JSON-LD nodes must be objects."
+    });
+    return;
+  }
+  if (value["@context"] !== void 0) {
+    validateContext(
+      value["@context"],
+      appendJsonPath(path, "@context"),
+      diagnostics
+    );
+  }
+  const typeValue = value["@type"];
+  if (typeValue !== void 0 && (getJsonLdTypes(typeValue).length === 0 || Array.isArray(typeValue) && typeValue.length === 0)) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@type"),
+      "@type must be a non-empty string or array of strings."
+    );
+  }
+  if (value["@id"] !== void 0 && typeof value["@id"] !== "string") {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@id"),
+      "@id must be a string."
+    );
+  }
+  if (value["@graph"] !== void 0 && isJsonObject(value["@graph"]) === false && Array.isArray(value["@graph"]) === false) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@graph"),
+      "@graph must be an object or array of objects."
+    );
+  }
+  if (value["@language"] !== void 0 && value["@language"] !== null && typeof value["@language"] !== "string") {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@language"),
+      "@language must be a string or null."
+    );
+  }
+  if (value["@nest"] !== void 0 && isJsonObject(value["@nest"]) === false && (Array.isArray(value["@nest"]) === false || value["@nest"].every(isJsonObject) === false)) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@nest"),
+      "@nest must be an object or array of objects."
+    );
+  }
+  if (value["@reverse"] !== void 0 && isJsonObject(value["@reverse"]) === false) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@reverse"),
+      "@reverse must be an object."
+    );
+  }
+  for (const keyword of ["@index"]) {
+    if (value[keyword] !== void 0 && typeof value[keyword] !== "string") {
+      pushKeywordTypeError(
+        diagnostics,
+        appendJsonPath(path, keyword),
+        `${keyword} must be a string.`
+      );
+    }
+  }
+  if (value["@direction"] !== void 0 && value["@direction"] !== "ltr" && value["@direction"] !== "rtl" && value["@direction"] !== null) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@direction"),
+      '@direction must be "ltr", "rtl", or null.'
+    );
+  }
+  if ("@value" in value) {
+    const invalidKeys = ["@id", "@graph", "@list", "@set", "@reverse"].filter(
+      (key) => key in value
+    );
+    const isJsonLiteral = value["@type"] === "@json";
+    const hasStructuredValue = typeof value["@value"] === "object" && value["@value"] !== null;
+    if (invalidKeys.length > 0 || hasStructuredValue && isJsonLiteral === false || "@type" in value && value["@type"] !== "@json" && ("@language" in value || "@direction" in value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid-value-object",
+        path,
+        message: "A JSON-LD value object has an incompatible keyword or @value shape."
+      });
+    }
+  }
+  for (const [property, propertyValue] of Object.entries(value)) {
+    const propertyPath = appendJsonPath(path, property);
+    if (property === "@context") {
+      continue;
+    }
+    if (["@graph", "@included", "@nest", "@reverse"].includes(property)) {
+      validateNode(propertyValue, propertyPath, diagnostics);
+      continue;
+    }
+    if (property.startsWith("@")) {
+      if (["@list", "@set"].includes(property)) {
+        validateNestedValues(propertyValue, propertyPath, diagnostics);
+      }
+      continue;
+    }
+    validateNestedValues(propertyValue, propertyPath, diagnostics);
+  }
+};
+var isJsonLdData = (value, ancestors) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null || ancestors.has(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (Array.isArray(value) === false && prototype !== Object.prototype) {
+    return false;
+  }
+  ancestors.add(value);
+  const isValid = Array.isArray(value) ? value.every((item) => isJsonLdData(item, ancestors)) : Object.values(value).every((item) => isJsonLdData(item, ancestors));
+  ancestors.delete(value);
+  return isValid;
+};
+var isJsonLdValue = (value) => (Array.isArray(value) || isJsonObject(value)) && isJsonLdData(value, /* @__PURE__ */ new Set());
+var parseJsonLd = (input2) => {
+  try {
+    const value = typeof input2 === "string" ? JSON.parse(input2) : input2;
+    if (isJsonLdValue(value)) {
+      return { success: true, value };
+    }
+  } catch {
+  }
+  return { success: false };
+};
+var validateJsonLd = (input2) => {
+  const parsed = parseJsonLd(input2);
+  if (parsed.success === false) {
+    return {
+      success: false,
+      diagnostics: [
+        {
+          severity: "error",
+          code: typeof input2 === "string" ? "invalid-json" : "invalid-root",
+          path: "$",
+          message: "JSON-LD must be a valid JSON object or array."
+        }
+      ]
+    };
+  }
+  const diagnostics = [];
+  validateNode(parsed.value, "$", diagnostics);
+  if (diagnostics.length > 0) {
+    return { success: false, value: parsed.value, diagnostics };
+  }
+  return { success: true, value: parsed.value, diagnostics };
+};
+var hasTopLevelJsonLdContext = (value) => {
+  if (Array.isArray(value)) {
+    return value.some(
+      (item) => typeof item === "object" && item !== null && "@context" in item
+    );
+  }
+  return "@context" in value;
+};
+
 // src/runtime.ts
 var tagProperty = "data-ws-tag";
 
@@ -2898,14 +3219,20 @@ var generateResources = ({
   resources: resources2
 }) => {
   const usedDataSources = /* @__PURE__ */ new Map();
+  const generatedResourceIds = /* @__PURE__ */ new Set();
   let generatedRequests = "";
   for (const resource3 of resources2.values()) {
+    generatedResourceIds.add(resource3.id);
     let generatedRequest = "";
     const resourceName = scope.getName(resource3.id, resource3.name);
     generatedRequest += `  const ${resourceName}: ResourceRequest = {
 `;
     generatedRequest += `    name: ${JSON.stringify(resource3.name)},
 `;
+    if (resource3.control !== void 0) {
+      generatedRequest += `    control: "${resource3.control}",
+`;
+    }
     const url2 = generateExpression({
       expression: resource3.url,
       dataSources: dataSources2,
@@ -2984,7 +3311,7 @@ var generateResources = ({
   generated += `  const _data = new Map<string, ResourceRequest>([
 `;
   for (const dataSource2 of dataSources2.values()) {
-    if (dataSource2.type === "resource") {
+    if (dataSource2.type === "resource" && generatedResourceIds.has(dataSource2.resourceId)) {
       const name = scope.getName(dataSource2.resourceId, dataSource2.name);
       generated += `    ["${name}", ${name}],
 `;
@@ -2995,7 +3322,7 @@ var generateResources = ({
   generated += `  const _action = new Map<string, ResourceRequest>([
 `;
   for (const prop2 of props2.values()) {
-    if (prop2.type === "resource") {
+    if (prop2.type === "resource" && generatedResourceIds.has(prop2.value)) {
       const name = scope.getName(prop2.value, prop2.name);
       generated += `    ["${name}", ${name}],
 `;
@@ -3069,6 +3396,26 @@ var replaceFormActionsWithResources = ({
 };
 
 // src/page-meta-generator.ts
+import { parseExpressionAt as parseExpressionAt2 } from "acorn";
+var normalizeStringExpression = (expression) => {
+  const trimmedExpression = expression.trim();
+  try {
+    const parsedExpression = parseExpressionAt2(trimmedExpression, 0, {
+      ecmaVersion: "latest"
+    });
+    if (parsedExpression.end === trimmedExpression.length) {
+      if (parsedExpression.type === "Identifier" && trimmedExpression !== "undefined" && trimmedExpression.includes("$ws$") === false) {
+        return JSON.stringify(expression);
+      }
+      return expression;
+    }
+  } catch {
+  }
+  if (trimmedExpression.includes("$ws$")) {
+    return expression;
+  }
+  return JSON.stringify(expression);
+};
 var generatePageMeta = ({
   globalScope,
   page: page2,
@@ -3078,13 +3425,13 @@ var generatePageMeta = ({
   const localScope = createScope(["system", "resources"]);
   const usedDataSources = /* @__PURE__ */ new Map();
   const titleExpression = generateExpression({
-    expression: page2.title,
+    expression: normalizeStringExpression(page2.title),
     dataSources: dataSources2,
     usedDataSources,
     scope: localScope
   });
   const descriptionExpression = generateExpression({
-    expression: page2.meta.description ?? "undefined",
+    expression: normalizeStringExpression(page2.meta.description ?? "undefined"),
     dataSources: dataSources2,
     usedDataSources,
     scope: localScope
@@ -3096,7 +3443,7 @@ var generatePageMeta = ({
     scope: localScope
   });
   const languageExpression = generateExpression({
-    expression: page2.meta.language ?? "undefined",
+    expression: normalizeStringExpression(page2.meta.language ?? "undefined"),
     dataSources: dataSources2,
     usedDataSources,
     scope: localScope
@@ -3105,7 +3452,9 @@ var generatePageMeta = ({
     page2.meta.socialImageAssetId ? assets2.get(page2.meta.socialImageAssetId)?.name : void 0
   );
   const socialImageUrlExpression = generateExpression({
-    expression: page2.meta.socialImageUrl ?? "undefined",
+    expression: normalizeStringExpression(
+      page2.meta.socialImageUrl ?? "undefined"
+    ),
     dataSources: dataSources2,
     usedDataSources,
     scope: localScope
@@ -3117,13 +3466,13 @@ var generatePageMeta = ({
     scope: localScope
   });
   const redirectExpression = generateExpression({
-    expression: page2.meta.redirect ?? "undefined",
+    expression: normalizeStringExpression(page2.meta.redirect ?? "undefined"),
     dataSources: dataSources2,
     usedDataSources,
     scope: localScope
   });
   const contentExpression = generateExpression({
-    expression: page2.meta.content ?? "undefined",
+    expression: normalizeStringExpression(page2.meta.content ?? "undefined"),
     dataSources: dataSources2,
     usedDataSources,
     scope: localScope
@@ -3137,7 +3486,7 @@ var generatePageMeta = ({
     }
     const propertyExpression = JSON.stringify(customMeta.property);
     const contentExpression2 = generateExpression({
-      expression: customMeta.content,
+      expression: normalizeStringExpression(customMeta.content),
       dataSources: dataSources2,
       usedDataSources,
       scope: localScope
@@ -3444,6 +3793,132 @@ ${userSheet.cssText}`,
     classes
   };
 };
+
+// src/input-json-schema.ts
+var unique = (values) => [...new Set(values)];
+var toInputJsonSchemaObject = (schema) => {
+  if (schema === void 0) {
+    return;
+  }
+  if (schema === true) {
+    return {};
+  }
+  if (schema === false) {
+    return { not: {} };
+  }
+  return schema;
+};
+var annotationInputJsonSchemaFields = /* @__PURE__ */ new Set(["description", "default"]);
+var isUnconstrainedInputJsonSchema = (schema) => Object.entries(schema).every(
+  ([field, value]) => value === void 0 || annotationInputJsonSchemaFields.has(field)
+);
+var inputJsonSchemaAcceptsType = (schema, type, options = {}) => {
+  if (options.treatUnconstrainedAsAny === true && isUnconstrainedInputJsonSchema(schema)) {
+    return true;
+  }
+  const schemaObject = toInputJsonSchemaObject(schema);
+  if (schemaObject === void 0) {
+    return false;
+  }
+  const types = schemaObject.type === void 0 ? [] : Array.isArray(schemaObject.type) ? schemaObject.type : [schemaObject.type];
+  if (types.includes(type)) {
+    return true;
+  }
+  if (type === "object" && (schemaObject.properties !== void 0 || schemaObject.required !== void 0 || schemaObject.additionalProperties !== void 0)) {
+    return true;
+  }
+  if (type === "array" && (schemaObject.items !== void 0 || schemaObject.prefixItems !== void 0 || schemaObject.minItems !== void 0 || schemaObject.maxItems !== void 0)) {
+    return true;
+  }
+  for (const combinator of ["anyOf", "oneOf"]) {
+    if (schemaObject[combinator] !== void 0) {
+      return schemaObject[combinator].some((item) => {
+        const itemSchema = toInputJsonSchemaObject(item);
+        return itemSchema === void 0 ? false : inputJsonSchemaAcceptsType(itemSchema, type, options);
+      });
+    }
+  }
+  if (schemaObject.allOf !== void 0) {
+    return schemaObject.allOf.length > 0 && schemaObject.allOf.every((item) => {
+      const itemSchema = toInputJsonSchemaObject(item);
+      return itemSchema === void 0 ? false : inputJsonSchemaAcceptsType(itemSchema, type, options);
+    });
+  }
+  return false;
+};
+var combineInputJsonSchemas = (left, right, combinator) => ({ [combinator]: [left, right] });
+var inputJsonSchemaCombinators = ["anyOf", "oneOf", "allOf"];
+var collectInputJsonSchemaBranchValue = (schema, readValue, combineValues) => {
+  let value = readValue(schema);
+  for (const combinator of inputJsonSchemaCombinators) {
+    for (const item of schema?.[combinator] ?? []) {
+      const itemSchema = toInputJsonSchemaObject(item);
+      const itemValue = collectInputJsonSchemaBranchValue(
+        itemSchema,
+        readValue,
+        combineValues
+      );
+      if (itemValue !== void 0) {
+        value = value === void 0 ? itemValue : combineValues(value, itemValue, combinator);
+      }
+    }
+  }
+  return value;
+};
+var mergeInputJsonSchemaProperties = (left, right, combinator) => {
+  const result = { ...left };
+  for (const [field, schema] of Object.entries(right)) {
+    const current = result[field];
+    result[field] = current === void 0 ? schema : combineInputJsonSchemas(current, schema, combinator);
+  }
+  return result;
+};
+var getInputJsonSchemaProperties = (schema) => collectInputJsonSchemaBranchValue(
+  schema,
+  (schema2) => {
+    const properties = Object.entries(schema2?.properties ?? {}).flatMap(
+      ([field, value]) => {
+        const valueSchema = toInputJsonSchemaObject(value);
+        return valueSchema === void 0 ? [] : [[field, valueSchema]];
+      }
+    );
+    return properties.length === 0 ? void 0 : Object.fromEntries(properties);
+  },
+  mergeInputJsonSchemaProperties
+);
+var getInputJsonSchemaAdditionalProperties = (schema) => collectInputJsonSchemaBranchValue(
+  schema,
+  (schema2) => typeof schema2?.additionalProperties === "object" ? schema2.additionalProperties : schema2?.additionalProperties === true ? {} : void 0,
+  combineInputJsonSchemas
+);
+var intersectStrings = (left, right) => left.filter((value) => right.includes(value));
+var getInputJsonSchemaRequiredFields = (schema) => {
+  if (schema === void 0) {
+    return [];
+  }
+  const allOfRequired = schema.allOf?.map(toInputJsonSchemaObject).filter((schema2) => schema2 !== void 0).flatMap(getInputJsonSchemaRequiredFields);
+  const anyBranchSchemas = [...schema.anyOf ?? [], ...schema.oneOf ?? []].map(toInputJsonSchemaObject).filter((schema2) => schema2 !== void 0);
+  const anyOfRequired = anyBranchSchemas.length === 0 ? void 0 : anyBranchSchemas.map(getInputJsonSchemaRequiredFields).reduce(intersectStrings);
+  return unique([
+    ...schema.required ?? [],
+    ...allOfRequired ?? [],
+    ...anyOfRequired ?? []
+  ]);
+};
+var getInputJsonSchemaMetadata = (inputSchema) => {
+  const properties = getInputJsonSchemaProperties(inputSchema) ?? {};
+  return {
+    inputFields: Object.keys(properties),
+    requiredInputFields: getInputJsonSchemaRequiredFields(inputSchema).filter(
+      (field) => field in properties
+    ),
+    inputFieldTypes: Object.fromEntries(
+      Object.entries(properties).flatMap(
+        ([field, schema]) => inputJsonSchemaAcceptsType(schema, "array") ? [[field, "array"]] : []
+      )
+    )
+  };
+};
 export {
   ALLOWED_FILE_EXTENSIONS,
   ALLOWED_FILE_TYPES,
@@ -3497,6 +3972,7 @@ export {
   elementComponent,
   encodeDataVariableId as encodeDataSourceVariable,
   encodeDataVariableId,
+  escapeJsonLdScriptText,
   executeExpression,
   expressionChild,
   fileAsset,
@@ -3524,20 +4000,30 @@ export {
   getHtmlTagFromInstance,
   getHtmlTagsFromProps,
   getIndexesWithinAncestors,
+  getInputJsonSchemaAdditionalProperties,
+  getInputJsonSchemaMetadata,
+  getInputJsonSchemaProperties,
   getMimeTypeByExtension,
   getMimeTypeByFilename,
   getPageById,
   getPagePath,
   getStaticSiteMapXml,
   getStyleDeclKey,
+  hasTopLevelJsonLdContext,
   homePagePath,
   idChild,
   imageAsset,
   imageMeta,
   initialBreakpoints,
+  inputJsonSchemaAcceptsType,
   insetUnitValue,
   instance,
+  instanceAttributes,
   instanceChild,
+  instanceComponent,
+  instanceCreateInput,
+  instanceFilterInput,
+  instanceTag,
   instances,
   isAbsoluteUrl,
   isAllowedExtension,
@@ -3553,6 +4039,7 @@ export {
   isRootFolder,
   lintExpression,
   matchPathnameParams,
+  normalizeComponentCategory,
   page,
   pageAuth,
   pageId,
@@ -3563,6 +4050,7 @@ export {
   pageTitle,
   pages,
   parseComponentName,
+  parseJsonLd,
   parseObjectExpression,
   portalComponent,
   presetStyleDecl,
@@ -3580,6 +4068,7 @@ export {
   resources,
   rootComponent,
   scrollAnimation,
+  shouldFilterComponentCategory,
   styleDecl,
   styleSource,
   styleSourceSelection,
@@ -3590,9 +4079,12 @@ export {
   tags,
   templates,
   textChild,
+  textChildValue,
+  toInputJsonSchemaObject,
   toRuntimeAsset,
   transpileExpression,
   validateFileName,
+  validateJsonLd,
   viewAnimation,
   webstudioFragment,
   wsComponentMeta