@inf-monkeys-tech/monkeys 1.1.13 → 1.1.15

package/lib/esm/runtime/index.mjs

@@ -23591,6 +23591,7 @@ function resolveThemeTokens(input) {
     return result;
   };
   for (const path of collected.keys()) resolveToken(path);
+  assertBentoTokens(resolved);
   const resolvedDocument = {};
   for (const token of resolved.values()) {
     const segments = token.path.split(".");
@@ -23703,6 +23704,35 @@ function assertMonkeysThemeTokensComplete(input) {
   }
   return resolved.document;
 }
+function assertBentoTokens(tokens) {
+  const fields = {
+    background: "color",
+    borderColor: "color",
+    borderWidth: "dimension",
+    borderStyle: "strokeStyle",
+    radius: "dimension",
+    shadow: "shadow",
+    padding: "dimension",
+    gap: "dimension"
+  };
+  for (const [path, token] of tokens) {
+    if (!path.startsWith("semantic.bento.")) continue;
+    const match = /^semantic\.bento\.(?:default|levels\.level([1-9]\d*))\.([a-zA-Z]+)(?:\.([a-z]+))?$/.exec(path);
+    const field = match?.[2];
+    const axis = match?.[3];
+    const expected = field && fields[field];
+    const modes = field === "padding" || field === "gap" ? ["compact", "default", "comfortable"] : ["light", "dark"];
+    if (!match || !expected || token.type !== expected || axis && !modes.includes(axis) || match[1] && !Number.isSafeInteger(Number(match[1]))) {
+      throw new ThemeTokenValidationError("Invalid Bento semantic token.", [{ path, message: "Expected a supported Bento field, type, level and mode." }]);
+    }
+    if (field === "borderStyle" && typeof token.value !== "string") {
+      throw new ThemeTokenValidationError("Invalid Bento border style.", [{ path, message: "Bento borders require a CSS stroke keyword." }]);
+    }
+    if (token.type === "dimension" && token.value.value < 0) {
+      throw new ThemeTokenValidationError("Invalid Bento dimension.", [{ path, message: "Bento dimensions must be non-negative." }]);
+    }
+  }
+}
 
 // src/contracts/theme.ts
 var ThemeTokenTypeSchema = z16.enum(THEME_TOKEN_TYPES);
@@ -24682,7 +24712,6 @@ var assertCompatibleCapabilityUpgrade = (previous, next) => {
   }
   const manifestContract = (entry) => ({
     kind: entry.manifest.kind,
-    ports: entry.manifest.ports,
     runtime: { ...entry.manifest.runtime, providerBindings: entry.manifest.runtime.providerBindings.map((binding) => ({ ...binding, providerRef: { ...binding.providerRef, version: void 0 } })) },
     placement: entry.manifest.placement,
     accessibility: entry.manifest.accessibility
@@ -24709,7 +24738,15 @@ var assertCompatibleCapabilityUpgrade = (previous, next) => {
   for (const direction of ["inputPorts", "outputPorts"]) {
     const oldPorts = oldRegistration[direction];
     const newPorts = newRegistration[direction];
-    if (oldPorts.length !== newPorts.length) throw new TypeError("Public runtime ports cannot be removed or replaced.");
+    const oldManifestPorts = previous.manifest.ports?.[direction === "inputPorts" ? "inputs" : "outputs"] ?? [];
+    const newManifestPorts = next.manifest.ports?.[direction === "inputPorts" ? "inputs" : "outputs"] ?? [];
+    for (const port of oldManifestPorts) {
+      const replacement = newManifestPorts.find((candidate) => candidate.name === port.name);
+      if (!replacement || canonicalContentHash(port) !== canonicalContentHash(replacement)) throw new TypeError("Published runtime port semantics changed.");
+    }
+    if (newManifestPorts.some((port) => port.required && !oldManifestPorts.some((previousPort) => previousPort.name === port.name)) || newPorts.some((port) => port.required && !oldPorts.some((previousPort) => previousPort.name === port.name))) {
+      throw new TypeError("New runtime ports must be optional for published declarations.");
+    }
     for (const port of oldPorts) {
       const replacement = newPorts.find((candidate) => candidate.name === port.name);
       if (!replacement || port.required !== replacement.required || port.multiple !== replacement.multiple) throw new TypeError("Public runtime port cardinality changed.");
@@ -24723,7 +24760,12 @@ var assertCompatibleCapabilityUpgrade = (previous, next) => {
   if (canonicalContentHash(requirements(oldRegistration)) !== canonicalContentHash(requirements(newRegistration))) {
     throw new TypeError("Runtime Ontology access requirements changed.");
   }
-  for (const key of ["allowedSideEffects", "actionRequirements", "allowedSlots", "supportedSurfaces", "allowedParentCapabilityRefs", "allowedChildCapabilityRefs"]) {
+  const existingOutputs = new Set(oldRegistration.outputPorts.map((port) => port.name));
+  const existingActions = newRegistration.actionRequirements.filter((requirement) => existingOutputs.has(requirement.outputPort));
+  if (canonicalContentHash(oldRegistration.actionRequirements) !== canonicalContentHash(existingActions)) {
+    throw new TypeError("Published output action and permission requirements changed.");
+  }
+  for (const key of ["allowedSideEffects", "allowedSlots", "supportedSurfaces", "allowedParentCapabilityRefs", "allowedChildCapabilityRefs"]) {
     if (canonicalContentHash(oldRegistration[key]) !== canonicalContentHash(newRegistration[key])) throw new TypeError(`Runtime contract ${key} changed.`);
   }
 };