@inf-monkeys-tech/monkeys 1.1.34 → 1.1.36

package/lib/esm/{chunk-ZN3TO3U7.mjs → chunk-AGT4MIWF.mjs}

@@ -4,7 +4,7 @@ import {
   PAGE_STREAM_MAX_FRAME_BYTES,
   PageStreamDescriptorSchema,
   PageStreamEventSchema
-} from "./chunk-IJ2W77NR.mjs";
+} from "./chunk-HLW3X2NX.mjs";
 import {
   AccessPolicySchema,
   ActionProgramDefinitionSchema,
@@ -26,6 +26,8 @@ import {
   DeclarativeRuntimeResolveResultSchema,
   DeclarativeShellResourceDocumentSchema,
   DeclarativeWorkbenchCatalogSchema,
+  DesignBoardChangesSchema,
+  DesignBoardDocumentSchema,
   DesignCapabilityCatalogArtifactSchema,
   DomainCommandDefinitionSchema,
   DomainCommandSchema,
@@ -39,6 +41,7 @@ import {
   LegacyRouteTakeoverAuthorizationSchema,
   MENU_ACTIVATION_QUERY_PARAMETER,
   MENU_CONTRACT_VERSION,
+  MaterializedModelProjectionSchema,
   MenuAccessRequirementSchema,
   MenuActionRegistrationSchema,
   MenuBoundedInputSchema,
@@ -110,7 +113,7 @@ import {
   require_validation,
   require_validation_error,
   resolveThemeTokens
-} from "./chunk-L5CYU6K4.mjs";
+} from "./chunk-GT5OGNJE.mjs";
 import {
   __commonJS,
   __toESM
@@ -2419,7 +2422,7 @@ var singleByStableIdentity = (registrations, kind, id, path) => {
 var usesResultValue = (mapping) => Object.values(mapping).some(
   (source) => source.kind === "result-field" || source.kind === "expression" && source.expression !== void 0 && collectPageExpressionReads(
     source.expression
-  ).some((read) => read.root === "result")
+  ).some((read2) => read2.root === "result")
 );
 var simpleEntityRef = (revisionRef) => ({
   kind: revisionRef.kind,
@@ -6180,6 +6183,55 @@ function resolveWorkflowColumnResult(binding, payload, nowMs = Date.now()) {
   return { value, expiresAt };
 }
 
+// src/runtime/design-board.ts
+var stable = (value) => JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
+var changed = (before, after, identity) => {
+  const previous = new Map(before.map((value) => [identity(value), stable(value)]));
+  return after.filter((value) => previous.get(identity(value)) !== stable(value));
+};
+function diffDesignBoardDocuments(before, after) {
+  const pageElements = (document, id) => document.document.elements.filter((element) => String(element.customData?.designBoard?.pageId || document.domain.pages[0]?.id) === id);
+  const removed = (left, right, identity) => {
+    const kept = new Set(right.map(identity));
+    return left.map(identity).filter((id) => !kept.has(id));
+  };
+  return DesignBoardChangesSchema.parse({
+    ...stable(before.document.appState) !== stable(after.document.appState) ? { appState: after.document.appState ?? {} } : {},
+    ...stable(before.domain.pages) !== stable(after.domain.pages) ? { pages: after.domain.pages } : {},
+    scenes: after.domain.pages.filter((page) => stable(pageElements(before, page.id)) !== stable(pageElements(after, page.id))).map((page) => ({ pageId: page.id, elements: pageElements(after, page.id) })),
+    nodes: changed(before.domain.nodes, after.domain.nodes, (node) => node.id),
+    removedNodeIds: removed(before.domain.nodes, after.domain.nodes, (node) => node.id),
+    connections: changed(before.domain.connections, after.domain.connections, (edge) => edge.id),
+    removedConnectionIds: removed(before.domain.connections, after.domain.connections, (edge) => edge.id),
+    files: changed(before.domain.files, after.domain.files, (file) => file.canonicalUri),
+    removedFileUris: removed(before.domain.files, after.domain.files, (file) => file.canonicalUri)
+  });
+}
+function applyDesignBoardChanges(document, changes) {
+  changes = DesignBoardChangesSchema.parse(changes);
+  const identities = [changes.scenes.map((scene) => scene.pageId), changes.nodes.map((node) => node.id), changes.connections.map((edge) => edge.id), changes.files.map((file) => file.canonicalUri)];
+  if (identities.some((ids) => new Set(ids).size !== ids.length)) throw new Error("DESIGN_BOARD_CHANGE_IDENTITIES_DUPLICATE");
+  const apply = (previous, updates, removed, identity) => {
+    const values = new Map(previous.map((item) => [identity(item), item]));
+    removed.forEach((id) => values.delete(id));
+    updates.forEach((item) => values.set(identity(item), item));
+    return [...values.values()];
+  };
+  const pages = changes.pages || document.domain.pages;
+  const pageIds = new Set(pages.map((page) => page.id));
+  if (changes.scenes.some((scene) => !pageIds.has(scene.pageId))) throw new Error("DESIGN_BOARD_CHANGE_PAGE_MISSING");
+  const scenes = new Map(changes.scenes.map((scene) => [scene.pageId, scene.elements]));
+  const elements = pages.flatMap((page) => scenes.get(page.id) ?? document.document.elements.filter((element) => String(element.customData?.designBoard?.pageId || document.domain.pages[0]?.id) === page.id));
+  const result = { ...document, document: { ...document.document, elements, files: {}, ...changes.appState === void 0 ? {} : { appState: changes.appState } }, domain: {
+    ...document.domain,
+    pages,
+    nodes: apply(document.domain.nodes, changes.nodes, changes.removedNodeIds, (node) => node.id).filter((node) => pageIds.has(node.pageId)),
+    connections: apply(document.domain.connections, changes.connections, changes.removedConnectionIds, (edge) => edge.id).filter((edge) => pageIds.has(edge.pageId)),
+    files: apply(document.domain.files, changes.files, changes.removedFileUris, (file) => file.canonicalUri)
+  } };
+  return DesignBoardDocumentSchema.parse(result);
+}
+
 // src/runtime/access-compiler.ts
 var uniqueBy = (values, key, label) => {
   const result = /* @__PURE__ */ new Map();
@@ -6604,6 +6656,152 @@ var preparePagePropertyProjection = (bindings) => {
 };
 var projectPageProperties = (base, bindings, context) => projectParsedProperties(base, parsePropertyBindings(bindings), context);
 
+// src/runtime/materialized-model.ts
+var unsafe2 = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function fail2(code) {
+  throw Object.assign(new Error(code), { code });
+}
+var object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : fail2("MATERIALIZED_MODEL_INVALID");
+var read = (value, path) => {
+  let current = value;
+  for (const key of path) {
+    if (unsafe2.has(key)) fail2("MATERIALIZED_MODEL_UNSAFE_PATH");
+    if (!current || typeof current !== "object" || !Object.prototype.hasOwnProperty.call(current, key)) fail2("MATERIALIZED_MODEL_PATH_MISSING");
+    current = current[key];
+  }
+  return current;
+};
+var integer = (value, min, max) => Number.isSafeInteger(value) && Number(value) >= min && Number(value) <= max ? Number(value) : fail2("MATERIALIZED_MODEL_INCOMPLETE");
+function assertMaterializedModelBudget(value, budget) {
+  const pending = [{ value, depth: 0 }];
+  let nodes = 0, bytes2 = 0;
+  while (pending.length) {
+    const item = pending.pop();
+    if (++nodes > budget.maxNodes || item.depth > 64) fail2("MATERIALIZED_MODEL_BUDGET");
+    bytes2 += 32;
+    const current = item.value;
+    if (typeof current === "string") bytes2 += current.length * 2;
+    else if (typeof current === "number" && !Number.isFinite(current)) fail2("MATERIALIZED_MODEL_INVALID");
+    else if (current !== null && typeof current === "object") {
+      if (Array.isArray(current) && current.length > Math.max(budget.maxItems, budget.maxRows)) fail2("MATERIALIZED_MODEL_BUDGET");
+      const prototype = Object.getPrototypeOf(current);
+      if (prototype !== Object.prototype && prototype !== Array.prototype && prototype !== null) fail2("MATERIALIZED_MODEL_INVALID");
+      for (const [key, child] of Object.entries(current)) {
+        if (unsafe2.has(key)) fail2("MATERIALIZED_MODEL_UNSAFE_PATH");
+        bytes2 += key.length * 2;
+        if (pending.length >= budget.maxNodes) fail2("MATERIALIZED_MODEL_BUDGET");
+        pending.push({ value: child, depth: item.depth + 1 });
+      }
+    } else if (current !== null && !["string", "number", "boolean"].includes(typeof current)) fail2("MATERIALIZED_MODEL_INVALID");
+    if (bytes2 > budget.maxBytes) fail2("MATERIALIZED_MODEL_BUDGET");
+  }
+}
+function assign(root, path, value) {
+  let target = root;
+  for (const key of path.slice(0, -1)) {
+    if (unsafe2.has(key) || !target || typeof target !== "object" || !Object.prototype.hasOwnProperty.call(target, key)) fail2("MATERIALIZED_MODEL_PATH_MISSING");
+    target = target[key];
+  }
+  const last = path[path.length - 1];
+  if (unsafe2.has(last) || !target || typeof target !== "object" || !Object.prototype.hasOwnProperty.call(target, last)) fail2("MATERIALIZED_MODEL_PATH_MISSING");
+  target[last] = value;
+}
+var overlaps = (a, b) => a.slice(0, Math.min(a.length, b.length)).every((key, index) => key === b[index]);
+var canonical = (value) => value && typeof value === "object" ? Array.isArray(value) ? "[" + value.map(canonical).join(",") + "]" : "{" + Object.keys(value).sort().map((key) => JSON.stringify(key) + ":" + canonical(value[key])).join(",") + "}" : JSON.stringify(value);
+function prepareMaterializedModelProjection(input) {
+  const config = MaterializedModelProjectionSchema.parse(input);
+  if (config.kind === "value") return (raw) => {
+    const selected = object2(read(raw, config.path));
+    assertMaterializedModelBudget(selected, config.budget);
+    return structuredClone(selected);
+  };
+  for (let i = 0; i < config.collections.length; i++)
+    if (config.collections.slice(i + 1).some((other) => overlaps(config.collections[i].path, other.path))) fail2("MATERIALIZED_MODEL_COLLECTION_OVERLAP");
+  return (raw) => {
+    const rows = read(raw, config.rowsPath);
+    if (!Array.isArray(rows) || !rows.length || rows.length > config.budget.maxRows) fail2("MATERIALIZED_MODEL_INCOMPLETE");
+    const parts = rows.map((row) => object2(read(row, config.valuePath)));
+    assertMaterializedModelBudget(parts, config.budget);
+    const batch = read(parts[0], config.batchPath);
+    if (typeof batch !== "string" || !batch.trim() || batch.length > 256) fail2("MATERIALIZED_MODEL_BATCH_MISMATCH");
+    const count = integer(read(parts[0], config.countPath), 1, config.budget.maxRows);
+    if (parts.length !== count) fail2("MATERIALIZED_MODEL_INCOMPLETE");
+    const ordered = new Array(count);
+    for (const part of parts) {
+      if (read(part, config.batchPath) !== batch || read(part, config.countPath) !== count) fail2("MATERIALIZED_MODEL_BATCH_MISMATCH");
+      const position = integer(read(part, config.indexPath), 0, count - 1);
+      if (ordered[position]) fail2("MATERIALIZED_MODEL_DUPLICATE_CHUNK");
+      ordered[position] = part;
+    }
+    const collections = config.collections.map((collection) => ({
+      config: collection,
+      expected: integer(read(ordered[0], collection.totalPath), 0, config.budget.maxItems),
+      items: [],
+      keys: /* @__PURE__ */ new Set()
+    }));
+    let base, header;
+    for (const part of ordered) {
+      const model = structuredClone(object2(read(part, config.modelPath)));
+      for (const collection of collections) {
+        if (read(part, collection.config.totalPath) !== collection.expected) fail2("MATERIALIZED_MODEL_COUNT_MISMATCH");
+        const items = read(model, collection.config.path);
+        if (!Array.isArray(items)) fail2("MATERIALIZED_MODEL_INVALID");
+        if (collection.items.length + items.length > config.budget.maxItems) fail2("MATERIALIZED_MODEL_BUDGET");
+        for (const item of items) {
+          if (collection.config.keyPath) {
+            const key = read(item, collection.config.keyPath);
+            if (typeof key !== "string" && !(typeof key === "number" && Number.isFinite(key))) fail2("MATERIALIZED_MODEL_INVALID_KEY");
+            const identity = typeof key + ":" + key;
+            if (collection.keys.has(identity)) fail2("MATERIALIZED_MODEL_DUPLICATE_ITEM");
+            collection.keys.add(identity);
+          }
+          collection.items.push(item);
+        }
+        assign(model, collection.config.path, []);
+      }
+      const currentHeader = canonical(model);
+      if (header !== void 0 && header !== currentHeader) fail2("MATERIALIZED_MODEL_HEADER_MISMATCH");
+      header = currentHeader;
+      base ?? (base = model);
+    }
+    for (const collection of collections) {
+      if (collection.items.length !== collection.expected) fail2("MATERIALIZED_MODEL_COUNT_MISMATCH");
+      assign(base, collection.config.path, collection.items);
+    }
+    assertMaterializedModelBudget(base, config.budget);
+    return base;
+  };
+}
+async function collectMaterializedModelPages(input) {
+  const config = MaterializedModelProjectionSchema.parse(input.projection);
+  if (config.kind !== "chunks" || !config.pagination) return input.first;
+  const rows = read(input.first.model, config.rowsPath);
+  if (!Array.isArray(rows)) fail2("MATERIALIZED_MODEL_INVALID");
+  if (rows.length > config.budget.maxRows) fail2("MATERIALIZED_MODEL_BUDGET");
+  let all = [...rows], current = input.first, pages = 1;
+  const cursors = /* @__PURE__ */ new Set();
+  assertMaterializedModelBudget(all, config.budget);
+  while (current.pageInfo?.hasMore) {
+    input.signal.throwIfAborted();
+    const cursor = current.pageInfo.nextCursor;
+    if (!cursor || cursors.has(cursor)) fail2("MATERIALIZED_MODEL_CURSOR_INVALID");
+    if (pages >= config.pagination.maxPages) fail2("MATERIALIZED_MODEL_PAGE_LIMIT");
+    cursors.add(cursor);
+    current = await input.query(cursor, input.signal);
+    input.signal.throwIfAborted();
+    const nextRows = read(current.model, config.rowsPath);
+    if (!Array.isArray(nextRows) || !nextRows.length) fail2("MATERIALIZED_MODEL_CURSOR_INVALID");
+    if (all.length + nextRows.length > config.budget.maxRows) fail2("MATERIALIZED_MODEL_BUDGET");
+    all.push(...nextRows);
+    pages++;
+    assertMaterializedModelBudget(all, config.budget);
+  }
+  input.signal.throwIfAborted();
+  const model = structuredClone(input.first.model);
+  assign(model, config.rowsPath, all);
+  return { ...input.first, model, pageInfo: { ...current.pageInfo, hasMore: false, nextCursor: void 0, returned: all.length } };
+}
+
 // src/runtime/record-editor-draft.ts
 var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 var recordEditorValuesEqual = (left, right) => {
@@ -7064,7 +7262,7 @@ var PageCompositionSchema = z2.object({
   body: SourceNode
 }).strict();
 var forbidden = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function assign(root, path, value) {
+function assign2(root, path, value) {
   let target = root;
   for (const [index, key] of path.entries()) {
     if (forbidden.has(String(key)) || ["id", "children", "data", "actions", "programActions", "on", "effects"].includes(String(path[0])))
@@ -7112,7 +7310,7 @@ function compilePageComposition(input) {
       for (const [name, binding] of Object.entries(definition.inputs ?? {})) {
         const supplied = Object.prototype.hasOwnProperty.call(value.inputs ?? {}, name) ? value.inputs[name] : binding.default;
         if (supplied === void 0) throw new TypeError(`Missing component input ${name}.`);
-        assign(root, binding.path, supplied);
+        assign2(root, binding.path, supplied);
       }
       for (const name of Object.keys(value.slots ?? {}))
         if (!definition.slots?.[name]) throw new TypeError(`Unknown component slot ${name}.`);
@@ -7221,6 +7419,8 @@ export {
   compileWorkflowPersistenceProjection,
   parseWorkflowColumnBinding,
   resolveWorkflowColumnResult,
+  diffDesignBoardDocuments,
+  applyDesignBoardChanges,
   compileProductAccessDeclaration,
   compileComponentAssemblyValidator,
   readPageValue,
@@ -7230,6 +7430,9 @@ export {
   preparePageExpression,
   preparePagePropertyProjection,
   projectPageProperties,
+  assertMaterializedModelBudget,
+  prepareMaterializedModelProjection,
+  collectMaterializedModelPages,
   recordEditorValuesEqual,
   recordEditorPathKey,
   createRecordEditorDraft,
@@ -7256,4 +7459,4 @@ export {
   PageCompositionSchema,
   compilePageComposition
 };
-//# sourceMappingURL=chunk-ZN3TO3U7.mjs.map
+//# sourceMappingURL=chunk-AGT4MIWF.mjs.map