@inf-monkeys-tech/monkeys 1.1.14 → 1.1.16

package/lib/esm/schemas/index.mjs

@@ -11229,6 +11229,34 @@ var PageNodeSchema = z15.lazy(
     children: z15.array(PageNodeSchema).optional()
   }).strict()
 );
+var PageSharedStateBindingSchema = z15.object({
+  bindingId: ContractIdentifierSchema,
+  provider: z15.object({ id: ContractIdentifierSchema, version: z15.number().int().positive() }).strict(),
+  states: z15.record(ContractIdentifierSchema, ContractIdentifierSchema).refine((value) => Object.keys(value).length > 0 && Object.keys(value).length <= 32, "Map 1\u201332 state slots."),
+  queries: z15.record(ContractIdentifierSchema, ContractIdentifierSchema).refine((value) => Object.keys(value).length <= 16, "Map at most 16 query slots."),
+  writeInteractions: z15.array(ContractIdentifierSchema).max(32)
+}).strict();
+var validateSharedStateBindings = (bindings, states, queryIds, interactions, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  const owned = /* @__PURE__ */ new Set();
+  for (const [index, binding] of (bindings ?? []).entries()) {
+    const issue = (message) => context.addIssue({ code: "custom", path: ["sharedStateBindings", index], message });
+    if (ids.has(binding.bindingId)) issue("Shared state binding ids must be unique.");
+    ids.add(binding.bindingId);
+    const mapped = Object.values(binding.states);
+    for (const id of mapped) {
+      if (owned.has(id)) issue("Shared state mappings must have one owner and distinct slots.");
+      owned.add(id);
+      if (!states.some((state) => state.stateId === id && !state.scopeNodeId)) issue(`Shared state ${id} must reference a declared root state.`);
+    }
+    for (const id of Object.values(binding.queries)) if (!queryIds.has(id)) issue(`Unknown shared state query ${id}.`);
+    if (new Set(binding.writeInteractions).size !== binding.writeInteractions.length) issue("Shared state write interactions must be unique.");
+    for (const id of binding.writeInteractions) {
+      const interaction = interactions.find((entry) => entry.bindingId === id);
+      if (!interaction || !mapped.includes(interaction.targetStateId)) issue(`Shared state write ${id} must target a mapped state.`);
+    }
+  }
+};
 var PageSchema = z15.object({
   contract: z15.literal("Page"),
   schemaVersion: z15.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
@@ -11243,6 +11271,7 @@ var PageSchema = z15.object({
   shell: ContractIdentifierSchema.optional(),
   body: PageNodeSchema,
   state: z15.array(PageStateSchema).optional(),
+  sharedStateBindings: z15.array(PageSharedStateBindingSchema).max(16).optional(),
   entryTransitions: z15.array(PageEntrySchema).optional(),
   access: AccessPolicySchema,
   managementAccess: ManagementAccessSchema,
@@ -11255,6 +11284,7 @@ var PageSchema = z15.object({
   const dataIds = /* @__PURE__ */ new Set();
   const actionIds = /* @__PURE__ */ new Set();
   const interactionIds = /* @__PURE__ */ new Set();
+  const sharedInteractions = [];
   const visit = (node, path) => {
     if (ids.has(node.id))
       context.addIssue({
@@ -11277,11 +11307,13 @@ var PageSchema = z15.object({
           });
         target.add(value.bindingId);
       }
+    sharedInteractions.push(...node.on ?? []);
     (node.children ?? []).forEach(
       (child, index) => visit(child, [...path, "children", index])
     );
   };
   visit(page.body, ["body"]);
+  validateSharedStateBindings(page.sharedStateBindings, page.state ?? [], dataIds, sharedInteractions, context);
   const stateIds = (page.state ?? []).map((entry) => entry.stateId);
   if (new Set(stateIds).size !== stateIds.length)
     context.addIssue({
@@ -11311,6 +11343,7 @@ var ResolvedPageSchema = z15.object({
   renderTree: RenderTreeSchema,
   capabilityInstances: z15.array(CapabilityInstanceSchema).min(1),
   stateDefinitions: z15.array(PageStateDefinitionSchema).optional(),
+  sharedStateBindings: z15.array(PageSharedStateBindingSchema).max(16).optional(),
   entryTransitions: z15.array(PageEntryTransitionSchema).optional(),
   interactionBindings: z15.array(InteractionBindingSchema).optional(),
   ontologyBindings: z15.array(PersistedOntologyBindingSchema),
@@ -11353,6 +11386,7 @@ var ResolvedPageSchema = z15.object({
       });
     }
   });
+  validateSharedStateBindings(value.sharedStateBindings, value.stateDefinitions ?? [], new Set([...value.queryBindings ?? [], ...value.ontologyBindings].map((binding) => binding.bindingId)), value.interactionBindings ?? [], context);
   const stateDefinitions = value.stateDefinitions ?? [];
   const entryTransitions = value.entryTransitions ?? [];
   const interactionBindings = value.interactionBindings ?? [];
@@ -13109,6 +13143,7 @@ var CompatiblePageRuntimeBundleSchema = z15.object({
   deniedCapabilityInstanceIds: z15.array(ContractIdentifierSchema).default([]),
   capabilityAccessEvaluated: z15.literal(true).optional(),
   stateDefinitions: z15.array(PageStateDefinitionSchema).default([]),
+  sharedStateBindings: z15.array(PageSharedStateBindingSchema).max(16).optional(),
   entryTransitions: z15.array(ResolvedPageEntryTransitionSchema).default([]),
   interactionBindings: z15.array(InteractionBindingSchema).default([]),
   ontologyBindings: z15.array(PersistedOntologyBindingSchema),
@@ -13125,6 +13160,7 @@ var CompatiblePageRuntimeBundleSchema = z15.object({
     "restricted"
   ])
 }).strict().superRefine((value, context) => {
+  validateSharedStateBindings(value.sharedStateBindings, value.stateDefinitions, new Set([...value.queryBindings, ...value.ontologyBindings].map((binding) => binding.bindingId)), value.interactionBindings, context);
   const instanceIds = new Set(
     value.capabilityInstances.map((instance) => instance.instanceId)
   );
@@ -18122,6 +18158,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(".");
@@ -18201,6 +18238,35 @@ var MONKEYS_REQUIRED_THEME_TOKEN_PATHS = Object.freeze({
   "semantic.spacing.global.comfortable": "dimension",
   "semantic.font.body": "fontFamily"
 });
+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 = z20.enum(THEME_TOKEN_TYPES);