@takeshape/cli 11.132.2 → 11.133.1

package/dist/index.js

@@ -2491,7 +2491,7 @@ var require_lib2 = __commonJS({
     function isColorSupported() {
       return typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported;
     }
-    var compose3 = (f, g) => (v) => f(g(v));
+    var compose2 = (f, g) => (v) => f(g(v));
     function buildDefs(colors) {
       return {
         keyword: colors.cyan,
@@ -2502,10 +2502,10 @@ var require_lib2 = __commonJS({
         string: colors.green,
         regex: colors.magenta,
         comment: colors.gray,
-        invalid: compose3(compose3(colors.white, colors.bgRed), colors.bold),
+        invalid: compose2(compose2(colors.white, colors.bgRed), colors.bold),
         gutter: colors.gray,
-        marker: compose3(colors.red, colors.bold),
-        message: compose3(colors.red, colors.bold),
+        marker: compose2(colors.red, colors.bold),
+        message: compose2(colors.red, colors.bold),
         reset: colors.reset
       };
     }
@@ -54031,7 +54031,7 @@ var require_async3 = __commonJS({
           );
         };
       }
-      var compose3 = function() {
+      var compose2 = function() {
         return seq.apply(null, slice(arguments).reverse());
       };
       var _concat = Array.prototype.concat;
@@ -54697,7 +54697,7 @@ var require_async3 = __commonJS({
         auto,
         autoInject,
         cargo,
-        compose: compose3,
+        compose: compose2,
         concat,
         concatLimit,
         concatSeries,
@@ -54799,7 +54799,7 @@ var require_async3 = __commonJS({
       exports3.auto = auto;
       exports3.autoInject = autoInject;
       exports3.cargo = cargo;
-      exports3.compose = compose3;
+      exports3.compose = compose2;
       exports3.concat = concat;
       exports3.concatLimit = concatLimit;
       exports3.concatSeries = concatSeries;
@@ -111466,7 +111466,7 @@ var require_nanomatch = __commonJS({
         };
       }
       if (Array.isArray(pattern)) {
-        return compose3(pattern, options2, matcher);
+        return compose2(pattern, options2, matcher);
       }
       if (pattern instanceof RegExp) {
         return test(pattern);
@@ -111572,7 +111572,7 @@ var require_nanomatch = __commonJS({
     nanomatch.clearCache = function() {
       nanomatch.cache.__data__ = {};
     };
-    function compose3(patterns, options2, matcher) {
+    function compose2(patterns, options2, matcher) {
       var matchers;
       return memoize2("compose", String(patterns), options2, function() {
         return function(file) {
@@ -112817,7 +112817,7 @@ var require_micromatch = __commonJS({
     };
     micromatch.matcher = function matcher(pattern, options2) {
       if (Array.isArray(pattern)) {
-        return compose3(pattern, options2, matcher);
+        return compose2(pattern, options2, matcher);
       }
       if (pattern instanceof RegExp) {
         return test(pattern);
@@ -112957,7 +112957,7 @@ var require_micromatch = __commonJS({
     function isEmptyString(val) {
       return String(val) === "" || String(val) === "./";
     }
-    function compose3(patterns, options2, matcher) {
+    function compose2(patterns, options2, matcher) {
       var matchers;
       return memoize2("compose", String(patterns), options2, function() {
         return function(file) {
@@ -206905,7 +206905,7 @@ var engines = {
 };
 var package_default = {
   name: "@takeshape/cli",
-  version: "11.132.2",
+  version: "11.133.1",
   description: "TakeShape CLI",
   homepage: "https://www.takeshape.io",
   repository: {
@@ -208503,13 +208503,6 @@ function ensureArray2(obj2) {
   return Array.isArray(obj2) ? obj2 : [obj2];
 }
 
-// ../util/dist/common/assert.js
-function assert(arg, message) {
-  if (!arg) {
-    throw new Error(message);
-  }
-}
-
 // ../util/dist/common/value.js
 function value(x2) {
   return () => x2;
@@ -208517,6 +208510,23 @@ function value(x2) {
 
 // ../util/dist/common/billing.js
 var DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL = 60;
+var DEFAULT_ENTITLEMENTS = {
+  users: 3,
+  apiRequests: 1e4,
+  apiRateLimit: 5,
+  contentEntries: 500,
+  roles: 5,
+  workflows: 0,
+  locales: 2,
+  webhooks: true,
+  providers: [],
+  importFromCSV: false,
+  minScheduleTriggerInterval: DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL,
+  bandwidth: 5,
+  apiCdn: false,
+  guards: 0,
+  staticSites: 0
+};
 
 // ../util/dist/common/types.js
 var import_isNull = __toESM(require_isNull(), 1);
@@ -217822,205 +217832,6 @@ var validate13 = createTypedValidator(schema13);
 var JSON_SHAPE_NAME = "JSON";
 
 // ../schema/dist/agents.js
-var END_AGENT_EXECUTION = "END";
-var EXECUTION_TYPE_CHAT = "chat";
-var EXECUTION_TYPE_GENERATE = "generate";
-function canEndOnState(state, includeSuspend = false) {
-  const { transitions } = state;
-  if (!transitions?.length) {
-    return true;
-  }
-  for (const step of transitions) {
-    if (includeSuspend && step.type === "suspend") {
-      return true;
-    }
-    if (step.destination === END_AGENT_EXECUTION) {
-      return true;
-    }
-    if (step.condition === void 0) {
-      return false;
-    }
-  }
-  return true;
-}
-function getAgentEndStates(agent, includeSuspend = false) {
-  const endStates = /* @__PURE__ */ new Set();
-  for (const [stateId, state] of Object.entries(agent.states)) {
-    if (canEndOnState(state, includeSuspend)) {
-      endStates.add(stateId);
-    }
-  }
-  return endStates;
-}
-var getSendAgentMessageShapeName = (agentName) => {
-  return `${(0, import_upperFirst2.default)(agentName)}SendAgentMessageResponse`;
-};
-var getAgentMessageShapeName = (inputName) => {
-  return `${(0, import_upperFirst2.default)(inputName)}AgentMessage`;
-};
-var getCreateAgentSessionMutationName = (agentName) => {
-  return `create${(0, import_upperFirst2.default)(agentName)}Session`;
-};
-var getInspectAgentQueryName = (agentName) => {
-  return `inspect${(0, import_upperFirst2.default)(agentName)}`;
-};
-var getSendAgentFeedbackMutationName = (agentName) => {
-  return `send${(0, import_upperFirst2.default)(agentName)}Feedback`;
-};
-var getSendAgentMessageMutationName = (inputName) => {
-  return `send${(0, import_upperFirst2.default)(inputName)}Message`;
-};
-var getGetAgentMessageQueryName = (inputName) => {
-  return `get${(0, import_upperFirst2.default)(inputName)}Message`;
-};
-var getAbortAgentMessageMutationName = (inputName) => {
-  return `abort${(0, import_upperFirst2.default)(inputName)}Message`;
-};
-function getAgentFeatures(agents) {
-  const result = {
-    queries: {},
-    mutations: {},
-    shapes: {}
-  };
-  for (const [agentName, agent] of Object.entries(agents)) {
-    const returnStates = [...getAgentEndStates(agent, true)];
-    const returnTypes = (0, import_uniq.default)(returnStates.map((stateId) => {
-      const { execution } = agent.states[stateId];
-      if (execution.type === EXECUTION_TYPE_CHAT) {
-        return shapeName2;
-      }
-      if (execution.type === EXECUTION_TYPE_GENERATE) {
-        return execution.outputShape ? execution.outputShape : "string";
-      }
-      return JSON_SHAPE_NAME;
-    }));
-    const shape = returnTypes.length === 0 ? "string" : returnTypes.length === 1 ? returnTypes[0] : JSON_SHAPE_NAME;
-    const sendAgentMessageResponseShapeName = getSendAgentMessageShapeName(agentName);
-    assert(result.shapes[sendAgentMessageResponseShapeName] === void 0, `Schema already has a shape with the name "${sendAgentMessageResponseShapeName}"`);
-    result.shapes[sendAgentMessageResponseShapeName] = {
-      id: sendAgentMessageResponseShapeName,
-      name: sendAgentMessageResponseShapeName,
-      title: sendAgentMessageResponseShapeName,
-      schema: {
-        type: "object",
-        properties: {
-          ...schema13.properties,
-          output: {
-            "@ref": shape
-          }
-        },
-        required: [...schema13.required],
-        additionalProperties: false
-      }
-    };
-    const createAgentSessionMutationName = getCreateAgentSessionMutationName(agentName);
-    assert(result.mutations[createAgentSessionMutationName] === void 0, `Schema already has a mutation with the name "${createAgentSessionMutationName}"`);
-    result.mutations[createAgentSessionMutationName] = {
-      description: `Create a session for the ${agentName} agent`,
-      shape: shapeName3,
-      resolver: {
-        name: "ai:createAgentSession",
-        agentName
-      }
-    };
-    for (const inputConfig of agent.api.inputs) {
-      if (inputConfig.type === "mutation") {
-        const inputName = inputConfig.name;
-        const sendAgentMessageMutationName = getSendAgentMessageMutationName(inputName);
-        assert(result.mutations[sendAgentMessageMutationName] === void 0, `Schema already has a mutation with the name "${sendAgentMessageMutationName}"`);
-        result.mutations[sendAgentMessageMutationName] = {
-          description: agent.description,
-          args: {
-            type: "object",
-            extends: [
-              {
-                ...propertySchema,
-                required: agent.protection?.enabled ? [...propertySchema.required, "token"] : propertySchema.required
-              },
-              {
-                "@ref": inputConfig.args
-              }
-            ]
-          },
-          shape: sendAgentMessageResponseShapeName,
-          resolver: {
-            name: "ai:sendAgentMessage",
-            agentName,
-            inputName
-          }
-        };
-        const agentMessageShapeName = getAgentMessageShapeName(inputName);
-        assert(result.shapes[agentMessageShapeName] === void 0, `Schema already has a shape with the name "${agentMessageShapeName}"`);
-        result.shapes[agentMessageShapeName] = {
-          id: agentMessageShapeName,
-          name: agentMessageShapeName,
-          title: agentMessageShapeName,
-          schema: {
-            type: "object",
-            properties: {
-              ...schema7.properties,
-              output: {
-                "@ref": shape
-              },
-              input: {
-                "@ref": inputConfig.args
-              }
-            },
-            required: [...schema7.required],
-            additionalProperties: false
-          }
-        };
-        const getAgentMessageQueryName = getGetAgentMessageQueryName(inputName);
-        assert(result.queries[getAgentMessageQueryName] === void 0, `Schema already has a query with the name ${getAgentMessageQueryName}`);
-        result.queries[getAgentMessageQueryName] = {
-          description: `Get a message for the ${agentName} agent`,
-          shape: agentMessageShapeName,
-          resolver: {
-            name: "ai:getAgentMessage",
-            agentName
-          },
-          args: {
-            ...schema5
-          }
-        };
-        const abortAgentMessageMutationName = getAbortAgentMessageMutationName(inputName);
-        assert(result.mutations[abortAgentMessageMutationName] === void 0, `Schema already has a mutation with the name ${abortAgentMessageMutationName}`);
-        result.mutations[abortAgentMessageMutationName] = {
-          description: `Abort a message for the ${agentName} agent`,
-          shape: shapeName,
-          resolver: {
-            name: "ai:abortAgentMessage",
-            agentName
-          },
-          args: {
-            ...schema5
-          }
-        };
-      }
-    }
-    result.queries[getInspectAgentQueryName(agentName)] ||= {
-      description: `Inspect the ${agentName} agent`,
-      args: {
-        ...schema8
-      },
-      shape: shapeName4,
-      resolver: {
-        name: "ai:inspectAgent",
-        agentName
-      }
-    };
-    result.mutations[getSendAgentFeedbackMutationName(agentName)] ||= {
-      description: `Send feedback for the ${agentName} agent`,
-      args: shapeName5,
-      shape: "boolean",
-      resolver: {
-        name: "ai:sendAgentFeedback",
-        agentName
-      }
-    };
-  }
-  return result;
-}
 function isValidAgentMutation(projectSchema, name) {
   for (const agent of Object.values(getAgentMap(projectSchema) ?? {})) {
     for (const input of agent.api.inputs) {
@@ -218031,28 +217842,6 @@ function isValidAgentMutation(projectSchema, name) {
   }
   return false;
 }
-function addAiQueries(projectSchema) {
-  const agents = getAgentMap(projectSchema);
-  if (!agents) {
-    return projectSchema;
-  }
-  const aiFeatures = getAgentFeatures(agents);
-  return {
-    ...projectSchema,
-    queries: {
-      ...projectSchema.queries,
-      ...aiFeatures.queries
-    },
-    mutations: {
-      ...projectSchema.mutations,
-      ...aiFeatures.mutations
-    },
-    shapes: {
-      ...projectSchema.shapes,
-      ...aiFeatures.shapes
-    }
-  };
-}
 var GUARDS_SCHEMA_PATH = ["guards"];
 var AGENTS_SCHEMA_PATH = ["agents"];
 var isGuardEnabled = (guard) => {
@@ -219248,6 +219037,93 @@ var builtInShapes = {
     title: "Asset Image Meta",
     schema: schema20
   },
+  TSReference: {
+    id: "TSReference",
+    name: "TSReference",
+    title: "TakeShape Reference",
+    schema: {
+      type: "object",
+      properties: {
+        _tid: {
+          type: "string"
+        },
+        data: {
+          "@ref": "TSSearchable",
+          "@resolver": {
+            name: "takeshape:get",
+            service: "takeshape",
+            args: {
+              ops: [{ path: "tid", mapping: "$source._tid" }]
+            }
+          }
+        }
+      },
+      required: ["_tid"]
+    }
+  },
+  TSEmbeddingSearchArgs: {
+    id: "TSEmbeddingSearchArgs",
+    name: "TSEmbeddingSearchArgs",
+    title: "Embedding Search Args",
+    schema: schema17
+  },
+  [shapeName6]: {
+    title: "Agent Run Mode",
+    id: shapeName6,
+    name: shapeName6,
+    schema: schema11
+  },
+  [shapeName9]: {
+    title: "Generate Args",
+    id: shapeName9,
+    name: shapeName9,
+    schema: schema16
+  },
+  [shapeName7]: {
+    title: "Chat Args",
+    id: shapeName7,
+    name: shapeName7,
+    schema: schema14
+  },
+  // Preserved for backward compatibility
+  [shapeName8]: {
+    title: "Chat Agent Response",
+    id: shapeName8,
+    name: shapeName8,
+    schema: schema15
+  },
+  [shapeName2]: {
+    title: "Chat Agent Payload",
+    id: shapeName2,
+    name: shapeName2,
+    schema: schema2
+  },
+  [shapeName4]: {
+    title: "Inspect Agent Response",
+    id: shapeName4,
+    name: shapeName4,
+    schema: schema9
+  },
+  [shapeName3]: {
+    title: "Create Agent Session Response",
+    id: shapeName3,
+    name: shapeName3,
+    schema: schema4
+  },
+  [shapeName]: {
+    title: "Abort Agent Message Response",
+    id: shapeName,
+    name: shapeName,
+    schema
+  },
+  [shapeName5]: {
+    title: "Send Agent Feedback Args",
+    id: shapeName5,
+    name: shapeName5,
+    schema: schema10
+  }
+};
+var staticSiteShapes = {
   TSStaticSite: {
     id: "SITE",
     name: "TSStaticSite",
@@ -219397,91 +219273,6 @@ var builtInShapes = {
         }
       }
     }
-  },
-  TSReference: {
-    id: "TSReference",
-    name: "TSReference",
-    title: "TakeShape Reference",
-    schema: {
-      type: "object",
-      properties: {
-        _tid: {
-          type: "string"
-        },
-        data: {
-          "@ref": "TSSearchable",
-          "@resolver": {
-            name: "takeshape:get",
-            service: "takeshape",
-            args: {
-              ops: [{ path: "tid", mapping: "$source._tid" }]
-            }
-          }
-        }
-      },
-      required: ["_tid"]
-    }
-  },
-  TSEmbeddingSearchArgs: {
-    id: "TSEmbeddingSearchArgs",
-    name: "TSEmbeddingSearchArgs",
-    title: "Embedding Search Args",
-    schema: schema17
-  },
-  [shapeName6]: {
-    title: "Agent Run Mode",
-    id: shapeName6,
-    name: shapeName6,
-    schema: schema11
-  },
-  [shapeName9]: {
-    title: "Generate Args",
-    id: shapeName9,
-    name: shapeName9,
-    schema: schema16
-  },
-  [shapeName7]: {
-    title: "Chat Args",
-    id: shapeName7,
-    name: shapeName7,
-    schema: schema14
-  },
-  // Preserved for backward compatibility
-  [shapeName8]: {
-    title: "Chat Agent Response",
-    id: shapeName8,
-    name: shapeName8,
-    schema: schema15
-  },
-  [shapeName2]: {
-    title: "Chat Agent Payload",
-    id: shapeName2,
-    name: shapeName2,
-    schema: schema2
-  },
-  [shapeName4]: {
-    title: "Inspect Agent Response",
-    id: shapeName4,
-    name: shapeName4,
-    schema: schema9
-  },
-  [shapeName3]: {
-    title: "Create Agent Session Response",
-    id: shapeName3,
-    name: shapeName3,
-    schema: schema4
-  },
-  [shapeName]: {
-    title: "Abort Agent Message Response",
-    id: shapeName,
-    name: shapeName,
-    schema
-  },
-  [shapeName5]: {
-    title: "Send Agent Feedback Args",
-    id: shapeName5,
-    name: shapeName5,
-    schema: schema10
   }
 };
 var builtInForms = {
@@ -219518,7 +219309,9 @@ var builtInForms = {
         }
       }
     }
-  },
+  }
+};
+var staticSiteForms = {
   TSStaticSite: {
     default: {
       order: ["title", "provider", "destination", "idKey", "secretKey", "environmentVariables"],
@@ -219698,6 +219491,11 @@ var builtInForms = {
     }
   }
 };
+function getBuiltInShapes(options2) {
+  return options2?.entitlements.staticSites ? { ...builtInShapes, ...staticSiteShapes } : builtInShapes;
+}
+var allBuiltInShapes = { ...builtInShapes, ...staticSiteShapes };
+var allBuiltInForms = { ...builtInForms, ...staticSiteForms };
 
 // ../schema/dist/constants.js
 var SERVICE_OBJECT_PATTERN_NAME = "pattern:service-object";
@@ -397562,15 +397360,9 @@ var getArgsType = (argsSchema) => {
 function isPropertySchemaWithRelationship(schema22) {
   return schema22["@resolver"]?.name === "shapedb:getRelated";
 }
-function isModelShape(shape) {
-  return Boolean(shape.model);
-}
 function isCachedShape(shape) {
   return shape.cache?.enabled === true && shape.loaders !== void 0;
 }
-function isReferenceableShape(shape) {
-  return Boolean(shape.loaders?.get);
-}
 
 // ../schema/dist/util/merge.js
 var import_assignWith = __toESM(require_assignWith(), 1);
@@ -397617,20 +397409,6 @@ function mergeSchemaProperties(parent, overrides, deep = false) {
   }
   return result;
 }
-function mergeFormProperties(parent, overrides) {
-  const result = {
-    ...parent,
-    properties: {
-      ...parent.properties,
-      ...overrides.properties
-    }
-  };
-  const order = (0, import_union.default)(parent.order, overrides.order);
-  if (order.length) {
-    result.order = order;
-  }
-  return result;
-}
 
 // ../schema/dist/util/shapes.js
 var import_find = __toESM(require_find2(), 1);
@@ -397739,9 +397517,6 @@ function shapeNameToRefItem(context, shapeName14, template) {
     template
   };
 }
-function shapeToRefString(context, shape) {
-  return serializeRef(shapeNameToRefItem(context, shape.name));
-}
 function getRef(context, refSchema) {
   if (refSchema["@ref"]) {
     const { shapeName: shapeName14, template } = parseTemplateShape(refSchema["@ref"]);
@@ -397867,13 +397642,6 @@ function dereferenceSchema(context, shapeOrFieldSchema, schemaPath = []) {
   };
   return resolveAll(shapeOrFieldSchema, schemaPath) ?? shapeOrFieldSchema;
 }
-function dereferenceObjectSchema(context, shapeOrFieldSchema, schemaPath = []) {
-  const schema22 = dereferenceSchema(context, shapeOrFieldSchema, schemaPath);
-  if (!isObjectSchema(schema22)) {
-    throw new Error(`provided schema at '${schemaPath.join(".")}' could not be resolved to an object schema`);
-  }
-  return schema22;
-}
 function getNamespace(context, layerId) {
   return context.services?.[layerId]?.namespace;
 }
@@ -398084,11 +397852,7 @@ function getStatusField(workflows, shape) {
 }
 
 // ../schema/dist/schema-util.js
-function isBuiltinShape(ref) {
-  const parsed = parseRef({}, ref);
-  return Boolean(parsed.layerId === "local" && builtInShapes[parsed.shapeName]);
-}
-var builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(builtInShapes));
+var builtInQueriesAndMutations = getShapeQueriesAndMutations(Object.values(allBuiltInShapes));
 function isBuiltinQuery(name) {
   return builtInQueriesAndMutations.queries[name] !== void 0;
 }
@@ -398286,17 +398050,6 @@ var DEFAULT_ID_FIELD = "id";
 function getIdField(obj2) {
   return obj2?.idField ?? DEFAULT_ID_FIELD;
 }
-function getCachedBuiltInProperties(shape, properties) {
-  const idField = getIdField(shape.cache);
-  return {
-    _id: {
-      title: "Id",
-      type: "string",
-      ...properties._id,
-      ...properties[idField]?.["@mapping"] ? { "@mapping": properties[idField]["@mapping"] } : {}
-    }
-  };
-}
 function getModelBuiltInProperties(projectSchema, shape) {
   const apiVersion = projectSchema.apiVersion ?? CURRENT_API_VERSION;
   const showDeprecationReason = apiVersion !== "1";
@@ -398388,94 +398141,6 @@ var BUILT_IN_PROPERTY_NAMES = {
   [BuiltInPropertiesProfile.Cached]: getBuiltInPropertyNames(BuiltInPropertiesProfile.Cached),
   [BuiltInPropertiesProfile.None]: getBuiltInPropertyNames(BuiltInPropertiesProfile.None)
 };
-function getBuiltInPropertiesProfile(shape) {
-  if (isModelShape(shape)) {
-    return BuiltInPropertiesProfile.Model;
-  }
-  if (isCachedShape(shape) || isReferenceableShape(shape)) {
-    return BuiltInPropertiesProfile.Cached;
-  }
-  return BuiltInPropertiesProfile.None;
-}
-function applyBuiltinPropertiesToShape(projectSchema, shape) {
-  const profile = getBuiltInPropertiesProfile(shape);
-  if (profile === BuiltInPropertiesProfile.None) {
-    return shape;
-  }
-  const shapeObjectSchema = dereferenceObjectSchema(projectSchema, shape.schema, ["shapes", shape.name]);
-  const { properties } = shapeObjectSchema;
-  const commonProperties = getCommonBuiltInProperties(shape);
-  const modelProperties = profile === BuiltInPropertiesProfile.Model ? getModelBuiltInProperties(projectSchema, shape) : void 0;
-  const cachedProperties = profile === BuiltInPropertiesProfile.Cached ? getCachedBuiltInProperties(shape, properties) : void 0;
-  return {
-    ...shape,
-    schema: {
-      ...shapeObjectSchema,
-      properties: {
-        ...properties,
-        ...commonProperties,
-        ...modelProperties,
-        ...cachedProperties
-      }
-    }
-  };
-}
-var requiredBuiltinShapes = ["Asset", "TSRelationship", "TSStaticSite", "TSUser"];
-function getBuiltinsUsed(projectSchema) {
-  const builtinsUsed = {};
-  const shapeNames = (0, import_uniq3.default)(requiredBuiltinShapes.concat(getAllRefs(projectSchema, (refItem) => refItem.layerId === "local" && isBuiltinShape(refItem.shapeName)).map((ref) => refItemToNamespacedShapeName(projectSchema, ref))));
-  const schemaWithAllBuiltins = {
-    ...emptySchema("project-id"),
-    shapes: builtInShapes
-  };
-  for (const builtinShapeName of shapeNames) {
-    builtinsUsed[builtinShapeName] = builtInShapes[builtinShapeName];
-    for (const depShapeName of getShapeDependencies(schemaWithAllBuiltins, builtInShapes[builtinShapeName])) {
-      builtinsUsed[depShapeName] = builtInShapes[depShapeName];
-    }
-  }
-  return builtinsUsed;
-}
-function applyDefaultsToSchema(projectSchema) {
-  const builtinsUsed = getBuiltinsUsed(projectSchema);
-  return {
-    ...projectSchema,
-    workflows: {
-      ...projectSchema.workflows,
-      ...workflowsEnabled(projectSchema.apiVersion) && {
-        default: defaultWorkflow
-      }
-    },
-    queries: {
-      ...builtInQueriesAndMutations.queries,
-      ...projectSchema.queries
-    },
-    mutations: {
-      ...builtInQueriesAndMutations.mutations,
-      ...projectSchema.mutations
-    },
-    shapes: (0, import_mapValues.default)({ ...builtinsUsed, ...projectSchema.shapes }, (shape) => {
-      const builtInShape = builtinsUsed[shape.name];
-      if (builtInShape && builtInShape !== shape) {
-        shape = {
-          ...shape,
-          schema: mergeSchemaProperties(dereferenceObjectSchema(projectSchema, shape.schema), dereferenceObjectSchema(projectSchema, builtInShape.schema))
-        };
-      }
-      return applyBuiltinPropertiesToShape(projectSchema, shape);
-    }),
-    forms: (0, import_mapValues.default)({ ...builtInForms, ...projectSchema.forms }, (formsConfig, shapeName14) => {
-      const builtInFormsConfig = builtInForms[shapeName14];
-      if (builtInFormsConfig && builtInFormsConfig !== formsConfig) {
-        formsConfig = {
-          ...formsConfig,
-          default: mergeFormProperties(formsConfig.default, builtInFormsConfig.default)
-        };
-      }
-      return formsConfig;
-    })
-  };
-}
 function getArgsReference(projectSchema, argsSchema) {
   const args = getArgs(argsSchema);
   if (args && typeof args === "string") {
@@ -398668,20 +398333,6 @@ function getStorageKey(schema22) {
   const first = findMapping(schema22, (mapping) => mapping.startsWith("shapedb:"));
   return first ? splitMapping(first)[1] : void 0;
 }
-function emptySchema(projectId) {
-  return {
-    projectId,
-    defaultLocale: "en-us",
-    locales: ["en-us"],
-    apiVersion: "2",
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    queries: {},
-    mutations: {},
-    shapes: {},
-    workflows: {},
-    forms: {}
-  };
-}
 var createSchemaPropertyList = (0, import_curry2.default)((context, shapeOrSchema) => {
   const propSchema = isShape(shapeOrSchema) ? shapeOrSchema.schema : shapeOrSchema;
   const schema22 = dereferenceSchema(context, propSchema, isShape(shapeOrSchema) ? ["shapes", shapeOrSchema.name] : void 0);
@@ -402067,10 +401718,6 @@ function getRelationshipShapes(shapes, refs) {
   const context = { shapes };
   return refs.map((ref) => getShapeByRef(context, ref)).filter(isDefined);
 }
-function getRelationshipShapeIds(shapes, refs) {
-  const context = { shapes };
-  return refs.map((ref) => getShapeByRef(context, ref)?.id).filter(isDefined);
-}
 function getRelationship(propertySchema2) {
   propertySchema2 = propertySchema2["@output"] ?? propertySchema2;
   if (!isPropertySchemaWithRelationship(propertySchema2)) {
@@ -402087,66 +401734,6 @@ function getRelationship(propertySchema2) {
     backreferenceName
   };
 }
-function addRelationship(relationships, id, env5) {
-  relationships[id] ||= [];
-  relationships[id].push(env5);
-}
-function findExistingRelationships(projectSchema, shapes) {
-  const relationships = {};
-  const shapeArray = Object.values(shapes);
-  const shapesSeen = /* @__PURE__ */ new Set();
-  const shapeIds = new Set(shapeArray.map((shape) => shape.id));
-  const findRelationships = (schema22, path16, parentShapeName) => {
-    const relationship = getRelationship(schema22);
-    if (relationship) {
-      const relatedShapeIds = getRelationshipShapeIds(shapes, relationship.refs);
-      const relatedName = schema22["@backreference"]?.name;
-      for (const shapeId5 of relatedShapeIds) {
-        if (shapeIds.has(shapeId5)) {
-          addRelationship(relationships, shapeId5, {
-            relatedName,
-            path: path16.slice(1),
-            shapeId: path16[0],
-            hasBackreference: Boolean(schema22["@backreference"]?.enabled),
-            schema: schema22,
-            shapeName: parentShapeName
-          });
-        }
-      }
-    }
-    const shapeName14 = getRefShapeName(projectSchema, schema22);
-    if (shapeName14 && !shapes[shapeName14]) {
-      return;
-    }
-    const prop = shapeName14 ? followRef(projectSchema, schema22) : schema22;
-    if (shapeName14) {
-      if (shapesSeen.has(shapeName14)) {
-        return;
-      }
-      shapesSeen.add(shapeName14);
-    }
-    if (!relationship) {
-      if (prop.properties) {
-        for (const name of Object.keys(prop.properties)) {
-          findRelationships(prop.properties[name], path16.concat(name), shapeName14 ?? parentShapeName);
-        }
-      } else if (prop.items) {
-        findRelationships(prop.items, path16, shapeName14 ?? parentShapeName);
-      } else if (isUnionSchema(prop)) {
-        for (const child of prop.oneOf) {
-          findRelationships(child, path16, shapeName14 ?? parentShapeName);
-        }
-      }
-    }
-  };
-  for (const shape of shapeArray) {
-    if (isModelShape(shape)) {
-      const { schema: schema22, id, name } = shape;
-      findRelationships(schema22, [id], name);
-    }
-  }
-  return relationships;
-}
 function isEqualRelationship(a3, b2) {
   const relationshipA = getRelationship(a3);
   const relationshipB = getRelationship(b2);
@@ -402164,84 +401751,6 @@ function isEqualRelationship(a3, b2) {
   const refSet = new Set(refsA);
   return refsB.every((ref) => refSet.has(ref));
 }
-function getRelatedShapeIds(relationships) {
-  return (0, import_uniq4.default)(relationships.map((rel) => rel.hasBackreference ? rel.shapeId : void 0).filter(isDefined));
-}
-function getShapes(projectSchema, shapeIds) {
-  return shapeIds.map((shapeId5) => getShapeById(projectSchema, shapeId5)).filter(isDefined);
-}
-function addRelatedFields(projectSchema, allRelationships) {
-  for (const [shapeId5, shapeRelationships] of Object.entries(allRelationships)) {
-    const shape = getShapeById(projectSchema, shapeId5);
-    if (shape && isObjectSchema(shape.schema)) {
-      const relatedShapeIds = getRelatedShapeIds(shapeRelationships);
-      const relatedShapeRefs = getShapes(projectSchema, relatedShapeIds).map((shape2) => shapeToRefString(projectSchema, shape2));
-      if (relatedShapeRefs.length) {
-        let shapeRef;
-        if (relatedShapeRefs.length === 1) {
-          shapeRef = relatedShapeRefs[0];
-        } else {
-          const shapeName14 = `${shape.name}Reference`;
-          shapeRef = shapeName14;
-          projectSchema.shapes[shapeName14] = {
-            id: shapeName14,
-            name: shapeName14,
-            title: shapeName14,
-            schema: {
-              oneOf: relatedShapeRefs.map((name) => ({
-                "@ref": name
-              }))
-            }
-          };
-        }
-        if (shapeRelationships.some((rel) => rel.hasBackreference)) {
-          shape.schema.properties._references = {
-            "@args": `TSListArgs<${shapeRef}>`,
-            "@ref": `PaginatedList<${shapeRef}>`,
-            "@resolver": {
-              name: "shapedb:list",
-              service: "shapedb",
-              args: {
-                ops: [
-                  { path: "$", mapping: "$args" },
-                  { path: "baseWhere._references.eq", mapping: "$source._id" },
-                  { path: "baseWhere._shapeId.in", value: relatedShapeIds }
-                ]
-              }
-            }
-          };
-        }
-      }
-      for (const relationship of shapeRelationships) {
-        const relatedShape = getShapeById(projectSchema, relationship.shapeId);
-        if (relatedShape && relationship.hasBackreference) {
-          const { relatedName } = relationship;
-          const relatedFieldName = relatedName ? relatedName : `${(0, import_camelCase2.default)(relatedShape.name)}Set`;
-          const filterField = relatedName ? relationship.path.concat("_id").join(".") : "_references";
-          shape.schema.properties[relatedFieldName] = {
-            "@args": `TSListArgs<${relatedShape.name}>`,
-            "@ref": `PaginatedList<${relatedShape.name}>`,
-            "@resolver": {
-              name: "shapedb:list",
-              service: "shapedb",
-              args: {
-                ops: [
-                  { path: "$", mapping: "$args" },
-                  {
-                    path: `baseWhere.${filterField}.eq`,
-                    mapping: "$source._id"
-                  },
-                  { path: "baseWhere._shapeId.eq", value: relatedShape.id }
-                ]
-              }
-            }
-          };
-        }
-      }
-    }
-  }
-  return projectSchema;
-}
 
 // ../schema/dist/schemas/auth-schemas.json
 var auth_schemas_default = {
@@ -404007,7 +403516,6 @@ function validateAgents(projectSchema) {
 }
 
 // ../schema/dist/validate/validate.js
-var builtInShapeNames = /* @__PURE__ */ new Set([...Object.keys(builtInShapes), ...scalars, "object"]);
 function findDuplicates(items) {
   const seen = {};
   for (const item2 of items) {
@@ -404114,13 +403622,13 @@ function enumerateBasicResolvers(resolver, path16) {
   visit10(resolver, path16);
   return results;
 }
-function validateResolver(projectSchema, basePath, baseResolver) {
+function validateResolver(context, projectSchema, basePath, baseResolver) {
   const errors = [];
   const isValidShapeName = (shapeName14) => {
     if (!shapeName14) {
       return false;
     }
-    const shape = getShape(projectSchema, shapeName14) ?? getShape({ shapes: builtInShapes }, shapeName14);
+    const shape = getShape(projectSchema, shapeName14) ?? getShape({ shapes: context.builtInShapes }, shapeName14);
     if (shape?.model) {
       return true;
     }
@@ -404246,16 +403754,16 @@ function validateResolver(projectSchema, basePath, baseResolver) {
   }
   return errors;
 }
-function validateLocalQueryConfig(projectSchema, query, operation, name) {
+function validateLocalQueryConfig(context, projectSchema, query, operation, name) {
   const location = operation === "query" ? "queries" : "mutations";
-  return validateResolver(projectSchema, [location, name, "resolver"], query.resolver);
+  return validateResolver(context, projectSchema, [location, name, "resolver"], query.resolver);
 }
 var operationProps = [["query", "queries"], ["mutation", "mutations"]];
-function validateLocalQueryConfigs(projectSchema) {
+function validateLocalQueryConfigs(context, projectSchema) {
   const errors = [];
   for (const [operation, prop] of operationProps) {
     for (const name of Object.keys(projectSchema[prop])) {
-      errors.push(...validateLocalQueryConfig(projectSchema, projectSchema[prop][name], operation, name));
+      errors.push(...validateLocalQueryConfig(context, projectSchema, projectSchema[prop][name], operation, name));
     }
   }
   return errors;
@@ -404373,8 +403881,8 @@ function validateLocalShapeJoinRef(projectSchema, item2) {
   }
   return [];
 }
-function validateLocalShapeJoins(projectSchema) {
-  return listShapeJoins(projectSchema).flatMap((item2) => validateLocalShapeJoinRef(projectSchema, item2).concat(validateResolver(projectSchema, item2.path.concat("resolver"), item2.join.resolver)));
+function validateLocalShapeJoins(context, projectSchema) {
+  return listShapeJoins(projectSchema).flatMap((item2) => validateLocalShapeJoinRef(projectSchema, item2).concat(validateResolver(context, projectSchema, item2.path.concat("resolver"), item2.join.resolver)));
 }
 async function validateShapeJoinRef(context, projectSchema, item2) {
   const refItem = parseRef(projectSchema, item2.ref);
@@ -404490,9 +403998,9 @@ function isAllOfPath(path16) {
 function isLocalRef(refItem) {
   return refItem.layerId === "local";
 }
-function validateLocalRefs(projectSchema) {
+function validateLocalRefs(context, projectSchema) {
   const errors = [];
-  const shapeNames = /* @__PURE__ */ new Set([...builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
+  const shapeNames = /* @__PURE__ */ new Set([...context.builtInShapeNames, ...Object.keys(projectSchema.shapes)]);
   const refs = getAllRefs(projectSchema).filter(isLocalRef);
   for (const item2 of refs) {
     if (item2.template && !isValidTemplate(item2.template)) {
@@ -404536,7 +404044,7 @@ function validateLocalRefs(projectSchema) {
 function isValidRef(context, projectSchema, layer, item2) {
   const { layerId } = item2;
   const shapeName14 = refItemToNamespacedShapeName(projectSchema, item2);
-  const localShapeExists = Boolean(projectSchema.shapes[shapeName14]) || builtInShapeNames.has(shapeName14);
+  const localShapeExists = Boolean(projectSchema.shapes[shapeName14]) || context.builtInShapeNames.has(shapeName14);
   return isValidServiceId(projectSchema, layerId) && (layerId === "local" ? localShapeExists : localShapeExists || isValidShapeReference(context, layer, shapeName14));
 }
 function mustBeInterface({ path: path16 }) {
@@ -404584,13 +404092,13 @@ function visitShapePropertiesJson(projectSchema, callback) {
     callback(property, propertyPath.slice(3, -2).split(`']['`));
   }, void 0);
 }
-function validateDirectives(projectSchema) {
+function validateDirectives(context, projectSchema) {
   const errors = [];
   visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
     const resolver = property["@resolver"];
     if (resolver) {
       const propPath = propertyPath.concat("@resolver");
-      const resolverErrors = validateResolver(projectSchema, propPath, resolver);
+      const resolverErrors = validateResolver(context, projectSchema, propPath, resolver);
       if (resolverErrors) {
         errors.push(...resolverErrors);
       }
@@ -404804,7 +404312,7 @@ function formatValidationResult(context, errors, schema22) {
 }
 function validateSyntax(context, schema22) {
   let errors = [];
-  errors = errors.concat(checkShapeNames(schema22.shapes)).concat(checkShapeIds(schema22.shapes)).concat(validateWorkflows(schema22)).concat(validateLocalQueryConfigs(schema22)).concat(validateLocalRefs(schema22)).concat(validateLocalShapeJoins(schema22)).concat(validateDirectives(schema22)).concat(validateLocales(schema22)).concat(checkWorkflowStepNames(schema22.workflows)).concat(checkWorkflowStepKeys(schema22.workflows)).concat(validateOneOfs(schema22)).concat(validateIndexedShapes(context, schema22)).concat(validateInterfaces(schema22)).concat(validateInterfaceImplementations(schema22)).concat(validateAgents(schema22)).concat(validateGuards(context, schema22));
+  errors = errors.concat(checkShapeNames(schema22.shapes)).concat(checkShapeIds(schema22.shapes)).concat(validateWorkflows(schema22)).concat(validateLocalQueryConfigs(context, schema22)).concat(validateLocalRefs(context, schema22)).concat(validateLocalShapeJoins(context, schema22)).concat(validateDirectives(context, schema22)).concat(validateLocales(schema22)).concat(checkWorkflowStepNames(schema22.workflows)).concat(checkWorkflowStepKeys(schema22.workflows)).concat(validateOneOfs(schema22)).concat(validateIndexedShapes(context, schema22)).concat(validateInterfaces(schema22)).concat(validateInterfaceImplementations(schema22)).concat(validateAgents(schema22)).concat(validateGuards(context, schema22));
   const mcpTools = getMcpToolMap(schema22);
   if (mcpTools) {
     errors = errors.concat(checkToolNames(mcpTools ?? {}));
@@ -404844,19 +404352,23 @@ function validateSchemaSyntax(obj2, options2 = {}) {
   }
   return validateStructure(schemaVersion, options2, obj2);
 }
-async function validateSchema(context, obj2) {
+async function validateSchema(options2, obj2) {
   if ((0, import_isUndefined3.default)(obj2)) {
     return schemaUndefinedResult;
   }
-  const contextWithDefaults = {
+  const builtInShapes2 = getBuiltInShapes({ entitlements: options2.entitlements ?? DEFAULT_ENTITLEMENTS });
+  const builtInShapeNames = /* @__PURE__ */ new Set([...Object.keys(builtInShapes2), ...scalars, "object"]);
+  const context = {
     allowDisconnectedLayers: true,
-    ...context
+    builtInShapes: builtInShapes2,
+    builtInShapeNames,
+    ...options2
   };
   const schemaVersion = normalizeSchemaVersion(obj2);
   if (!schemaVersion) {
     return invalidVersionResult;
   }
-  const structuralValidation = validateStructure(schemaVersion, contextWithDefaults, obj2);
+  const structuralValidation = validateStructure(schemaVersion, context, obj2);
   if (!structuralValidation.valid || context.structureOnly) {
     return structuralValidation;
   }
@@ -404864,9 +404376,9 @@ async function validateSchema(context, obj2) {
   if (!isLatestProjectSchemaJSON(schema22)) {
     return invalidVersionResult;
   }
-  const syntaxValidation = validateSyntax(contextWithDefaults, schema22);
+  const syntaxValidation = validateSyntax(context, schema22);
   const validateReferencesContext = {
-    ...contextWithDefaults,
+    ...context,
     projectSchema: schema22
   };
   if (!syntaxValidation.valid || !isValidateReferencesContext(validateReferencesContext)) {
@@ -405684,42 +405196,14 @@ var templateMappings = {
   DuplicateResult,
   DeleteResult
 };
-function resolveTemplate(projectSchema, templateName, shapeName14) {
-  const mapping = templateMappings[templateName];
-  if (!mapping) {
-    throw new Error(`Invalid shape template ${templateName}`);
-  }
-  if (projectSchema.shapes[shapeName14] === void 0) {
-    throw new Error(`Unknown shape "${shapeName14}" in template "${templateName}"`);
-  }
-  return mapping({ projectSchema }, projectSchema.shapes[shapeName14]);
-}
 function isValidTemplate(template) {
   return Boolean(templateMappings[template]);
 }
 
-// ../schema/dist/flatten-templates.js
-function flattenTemplates(projectSchema) {
-  const templateRefs = getAllRefs(projectSchema, (ref) => Boolean(ref.template));
-  if (!templateRefs.length) {
-    return projectSchema;
-  }
-  const newSchema = deepClone(projectSchema);
-  for (const ref of templateRefs) {
-    if (ref.template && isValidTemplate(ref.template)) {
-      const { shapeName: shapeName14, dependencies } = resolveTemplate(newSchema, ref.template, refItemToNamespacedShapeName(newSchema, ref));
-      (0, import_set9.default)(newSchema, ref.path, ref.path[ref.path.length - 1] === "@ref" ? `local:${shapeName14}` : shapeName14);
-      Object.assign(newSchema.shapes, dependencies);
-    }
-  }
-  return newSchema;
-}
-
 // ../schema/dist/interfaces.js
 var import_mapValues9 = __toESM(require_mapValues(), 1);
 
 // ../schema/dist/runtime-schema.js
-var import_compose2 = __toESM(require_compose(), 1);
 var import_isError = __toESM(require_isError(), 1);
 var import_set11 = __toESM(require_set2(), 1);
 
@@ -405729,59 +405213,6 @@ var import_isObject3 = __toESM(require_isObject(), 1);
 var import_pick5 = __toESM(require_pick(), 1);
 var import_set10 = __toESM(require_set2(), 1);
 
-// ../schema/dist/runtime-schema.js
-function applyLegacyCompatibilityTweaks(projectSchema) {
-  const newSchema = deepClone(projectSchema);
-  let hasSearchableShapes = false;
-  for (const [shapeName14, shape] of Object.entries(newSchema.shapes)) {
-    if (isModelShape(shape)) {
-      hasSearchableShapes = true;
-      (0, import_set11.default)(shape, ["schema", "properties", "_contentTypeId"], {
-        type: "string"
-      });
-      (0, import_set11.default)(shape, ["schema", "properties", "_contentTypeName"], {
-        type: "string"
-      });
-      if (shape.model?.type !== "single") {
-        newSchema.queries[`search${shapeName14}Index`] = {
-          shape: `SearchResults<${shapeName14}>`,
-          resolver: {
-            name: "takeshape:search",
-            service: "takeshape",
-            shapeName: shapeName14
-          },
-          args: `TSSearchArgs<${shapeName14}>`
-        };
-      }
-    }
-    if (shapeName14 === ASSET_SHAPE_NAME) {
-      (0, import_set11.default)(shape, ["schema", "properties", "s3Key"], {
-        title: "s3 key",
-        type: "string",
-        "@mapping": "shapedb:Asset.Hk6FQuz5",
-        "@deprecationReason": "Use path instead"
-      });
-    }
-  }
-  if (hasSearchableShapes) {
-    newSchema.shapes.TSSearchable = createShape("TSSearchable", {
-      type: "object",
-      properties: {}
-    });
-    newSchema.queries.search = {
-      shape: "SearchResults<TSSearchable>",
-      resolver: {
-        name: "takeshape:search",
-        service: "takeshape"
-      },
-      args: "TSSearchArgs<TSSearchable>"
-    };
-  }
-  addRelatedFields(newSchema, findExistingRelationships(projectSchema, projectSchema.shapes));
-  return newSchema;
-}
-var applyDefaultsAndFlatten = (0, import_compose2.default)(flattenTemplates, applyLegacyCompatibilityTweaks, applyDefaultsToSchema, addAiQueries);
-
 // ../schema/dist/schema-transform.js
 var import_pickBy3 = __toESM(require_pickBy(), 1);
 function toName(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/cli",
-  "version": "11.132.2",
+  "version": "11.133.1",
   "description": "TakeShape CLI",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -69,11 +69,11 @@
     "stream-to-promise": "2.2.0",
     "tmp": "0.0.33",
     "unzipper": "0.10.11",
-    "@takeshape/branches": "11.132.2",
-    "@takeshape/ssg": "11.132.2",
-    "@takeshape/streams": "11.132.2",
-    "@takeshape/util": "11.132.2",
-    "@takeshape/schema": "11.132.2"
+    "@takeshape/ssg": "11.133.1",
+    "@takeshape/branches": "11.133.1",
+    "@takeshape/schema": "11.133.1",
+    "@takeshape/streams": "11.133.1",
+    "@takeshape/util": "11.133.1"
   },
   "engines": {
     "node": ">=22"