@sparkerp/plugin-sdk 0.1.0 → 1.1.0

package/bundle/validators/page-engine.mjs

@@ -3061,6 +3061,25 @@ function endsWith(args) {
   const [s, suffix] = args;
   return rvBool(str(s).endsWith(str(suffix)));
 }
+function displayString(v) {
+  switch (v.type) {
+    case "String":
+      return v.value;
+    case "Integer":
+      return v.value.toString();
+    case "Decimal":
+      return v.value.toString();
+    case "Boolean":
+      return String(v.value);
+    case "Null":
+      return "";
+    default:
+      throw new EvaluationError(`concat() does not support ${v.type} operands`);
+  }
+}
+function concatFn(args) {
+  return rvString(args.map(displayString).join(""));
+}
 function registerStringFunctions(registry, version) {
   registry.register(version, "upper", upper);
   registry.register(version, "lower", lower);
@@ -3069,6 +3088,7 @@ function registerStringFunctions(registry, version) {
   registry.register(version, "substring", substring);
   registry.register(version, "startsWith", startsWith);
   registry.register(version, "endsWith", endsWith);
+  registry.register(version, "concat", concatFn);
 }
 function contains(args) {
   const [collection, needle] = args;
@@ -3115,12 +3135,19 @@ function size(args) {
 function isEmpty(args) {
   return rvBool(sizeOf(args[0]) === 0);
 }
+function pluck(args) {
+  const [arr, key] = args;
+  if (arr.type !== "Array") throw new EvaluationError(`pluck() expects an Array as its first argument, got ${arr.type}`);
+  if (key.type !== "String") throw new EvaluationError("pluck() expects a String field name as its second argument");
+  return rvArray(arr.value.map((row) => row.type === "Object" ? row.value[key.value] ?? RV_NULL : RV_NULL));
+}
 function registerCollectionFunctions(registry, version) {
   registry.register(version, "contains", contains);
   registry.register(version, "first", first);
   registry.register(version, "last", last);
   registry.register(version, "size", size);
   registry.register(version, "isEmpty", isEmpty);
+  registry.register(version, "pluck", pluck);
 }
 function ifImpl(args) {
   const [cond, thenValue, elseValue] = args;
@@ -3193,12 +3220,14 @@ var FUNCTION_CATALOG = [
   c({ name: "substring", minArity: 2, maxArity: 3, argKinds: ["String", "Numeric", "Numeric"], returnType: "String", category: "String", description: "Part of a string from a 0-based start position, optionally limited to a length." }),
   c({ name: "startsWith", minArity: 2, maxArity: 2, argKinds: ["String", "String"], returnType: "Boolean", category: "String", description: "True when the string begins with the given prefix." }),
   c({ name: "endsWith", minArity: 2, maxArity: 2, argKinds: ["String", "String"], returnType: "Boolean", category: "String", description: "True when the string ends with the given suffix." }),
+  c({ name: "concat", minArity: 2, maxArity: Infinity, argKinds: ["Any"], returnType: "String", category: "String", description: `Joins 2+ values' display text into one string, e.g. concat("Total: ", page.count).` }),
   // Collection
   c({ name: "contains", minArity: 2, maxArity: 2, argKinds: ["Collection", "Any"], returnType: "Boolean", category: "Collection", description: "True when a list, string, or object contains the given element/substring/key." }),
   c({ name: "first", minArity: 1, maxArity: 1, argKinds: ["Array"], returnType: "Any", category: "Collection", description: "The first element of a list." }),
   c({ name: "last", minArity: 1, maxArity: 1, argKinds: ["Array"], returnType: "Any", category: "Collection", description: "The last element of a list." }),
   c({ name: "size", minArity: 1, maxArity: 1, argKinds: ["Collection"], returnType: "Integer", category: "Collection", description: "Number of elements in a list, characters in a string, or keys in an object." }),
   c({ name: "isEmpty", minArity: 1, maxArity: 1, argKinds: ["Collection"], returnType: "Boolean", category: "Collection", description: "True when a list, string, or object has no elements." }),
+  c({ name: "pluck", minArity: 2, maxArity: 2, argKinds: ["Array", "String"], returnType: "Array", category: "Collection", description: `pluck(rows, "fieldName") \u2014 a new list of that field's value from each object in the list, e.g. turning [{date, value}, ...] into [value, value, ...].` }),
   // Utility
   c({ name: "if", minArity: 3, maxArity: 3, argKinds: ["Boolean", "Any", "Any"], returnType: "Any", category: "Utility", description: "if(condition, thenValue, elseValue) \u2014 returns one of two values based on a condition." }),
   c({ name: "coalesce", minArity: 1, maxArity: Infinity, argKinds: ["Any"], returnType: "Any", category: "Utility", description: "The first argument that is not null." }),
@@ -4425,9 +4454,9 @@ function resolvePath(scopes, rawPath) {
   return value;
 }
 function resolveString(scopes, text) {
-  const pluck = PLUCK_TEMPLATE.exec(text);
-  if (pluck) {
-    const [, path, field] = pluck;
+  const pluck2 = PLUCK_TEMPLATE.exec(text);
+  if (pluck2) {
+    const [, path, field] = pluck2;
     const resolved = runtimeValueToJs(resolvePath(scopes, path));
     if (!Array.isArray(resolved)) {
       throw new ActionError("unresolved-variable", `'${path}|pluck:${field}' requires an array at '${path}'`);
@@ -10320,6 +10349,26 @@ ${failedSteps}` : "")
     });
     if (faulted && this.phase === "ready") this.present();
   }
+  /**
+   * A real, previously-undiscovered gap (2026-09-22, found live authoring the HCM Permissions
+   * "Create Permission" dialog): a `core.text-input` (or any other inputClass block) whose page
+   * JSON only ever sets `properties.value.binding` — the "obviously two-way" way EVERY such field
+   * in this codebase's own already-shipped pages is authored (`hcm-users.json`'s Create User
+   * dialog included) — never actually wrote a keystroke back to that bound page-scope key. `commit`
+   * → `writeOutput` only ever consulted `config.outputs[name]`, a SEPARATE, explicit redirect
+   * nothing in this codebase's own page-authoring convention ever sets; absent that, every write
+   * landed in a `{scope:"block", scopeKey:this.instanceId}` bucket no page action chain can ever
+   * read — the DOM still showed the typed characters (via `RevealableTextField`'s own local echo
+   * state), so this was invisible in every purely-visual check, only surfacing when a create
+   * dialog's Submit button's `${page.createX}` params were inspected against the REAL network
+   * payload, which showed every field empty. Fixed by falling back to the SAME resolved binding
+   * target `resolveProperties()` already computed for the identically-named PROPERTY's own read
+   * side (`this.boundProps`) when no explicit `config.outputs[name]` redirect exists — making a
+   * `source:"binding"` property's own binding genuinely two-way by default, matching what every
+   * page author already (reasonably) assumed it meant. An explicit `config.outputs[name]` still
+   * wins unchanged (e.g. `core.file-upload`'s own redirect to a different scope/key than its
+   * `value` property reads from); this only fills in the previously-silent gap.
+   */
   async writeOutput(name, value) {
     const port = (this.type.definition.outputs ?? []).find((o) => o.name === name);
     if (!port) {
@@ -10327,7 +10376,7 @@ ${failedSteps}` : "")
       return;
     }
     const redirect = this.config.outputs?.[name];
-    const target = redirect ? resolveBoundKey(redirect, this.bindingContext()) : { scope: "block", scopeKey: this.instanceId, key: name };
+    const target = redirect ? resolveBoundKey(redirect, this.bindingContext()) : this.boundProps.get(name) ?? { scope: "block", scopeKey: this.instanceId, key: name };
     await this.ctx.state.set(target, value);
   }
   /* ---------------- error isolation & standard states (W2-04) ---------------- */
@@ -10918,6 +10967,47 @@ var imageDefinition = definition({
       type: "string",
       sources: ["static"],
       designer: { group: "content", editor: "text", labelKey: "core.image.property.height" }
+    },
+    {
+      // 2026-09-17 (page-builder "Customize" panel parity) — a clip-path-class
+      // shape, the same fixed vocabulary a real page-builder's own "Shape"
+      // picker offers (never an arbitrary path — that stays a `style`
+      // escape-hatch concern).
+      name: "shape",
+      type: "string",
+      sources: ["static"],
+      default: "none",
+      constraints: { options: [{ value: "none", labelKey: "core.image.shape.none" }, { value: "circle", labelKey: "core.image.shape.circle" }, { value: "rounded", labelKey: "core.image.shape.rounded" }] },
+      designer: { group: "content", editor: "select", labelKey: "core.image.property.shape" }
+    },
+    {
+      /** A native browser tooltip (HTML `title` attribute) — distinct from `alt` (accessibility text, always present) and from a rich hover-card (out of scope here, a real different feature). */
+      name: "tooltip",
+      type: "string",
+      sources: ["static"],
+      designer: { group: "content", editor: "text", labelKey: "core.image.property.tooltip" }
+    },
+    {
+      /** A raw CSS `transform` value, e.g. "rotate(4deg)" — same "text travels as data" posture as `PageTheme.customCss`, never `dangerouslySetInnerHTML`, just an inline style value. */
+      name: "transform",
+      type: "string",
+      sources: ["static"],
+      designer: { group: "content", editor: "text", labelKey: "core.image.property.transform" }
+    },
+    {
+      name: "filter",
+      type: "string",
+      sources: ["static"],
+      default: "none",
+      constraints: {
+        options: [
+          { value: "none", labelKey: "core.image.filter.none" },
+          { value: "grayscale", labelKey: "core.image.filter.grayscale" },
+          { value: "sepia", labelKey: "core.image.filter.sepia" },
+          { value: "blur", labelKey: "core.image.filter.blur" }
+        ]
+      },
+      designer: { group: "content", editor: "select", labelKey: "core.image.property.filter" }
     }
   ],
   events: [],
@@ -13562,6 +13652,31 @@ var gridDefinition = definition({
       designer: { group: "data", editor: "binding", labelKey: "core.grid.property.refreshTrigger" }
     }
   ],
+  // 2026-09-23 — these are the block's own internal state (written via
+  // `io.setOwnState` in this file's `query()`/handlers, read back into
+  // `node.props` for the adapter), not authored properties: a page author
+  // never sets them, but a plugin/theme developer inspecting `core.grid`
+  // via `erp blocks list --type core.grid` had no way to discover they
+  // exist at all — the empty-grid production bug this session traced back
+  // to exactly this state (rows/total both came from the same query
+  // response, one reached the render, the other didn't) took a live
+  // Playwright session plus a source read to pin down, when this list
+  // alone would have shown the full internal-state surface immediately.
+  outputs: [
+    { name: "rows", type: "json" },
+    { name: "total", type: "number" },
+    { name: "pageIndex", type: "number" },
+    { name: "sort", type: "json" },
+    { name: "filter", type: "json" },
+    { name: "groups", type: "json" },
+    { name: "aggregates", type: "json" },
+    { name: "expandedGroups", type: "json" },
+    { name: "error", type: "string" },
+    { name: "circuitOpen", type: "boolean" },
+    { name: "selectedIds", type: "json" },
+    { name: "density", type: "string" },
+    { name: "groupBy", type: "string" }
+  ],
   events: [
     { name: "selectionChanged", catalogType: "GridSelectionChanged" },
     { name: "rowClicked", catalogType: "GridRowClicked" },
@@ -14311,6 +14426,30 @@ var fileUploadDefinition = definition({
       type: "string",
       sources: ["static", "expression"],
       designer: { group: "data", editor: "text", labelKey: "core.file-upload.property.cabinetId" }
+    },
+    {
+      // 2026-09-21 (HCM Users spec gap-closing pass) — every pre-existing
+      // page never sets this (undefined === "dms"), so it's a zero-risk
+      // addition: `"dms"` keeps today's exact behavior (a real DMS cabinet
+      // upload via the injected `FileUploadSource`, `value` becomes real
+      // `UploadedFileRef`s). `"raw"` skips the DMS upload entirely — `value`
+      // becomes the picked file's own `{filename, contentType, dataUrl}`
+      // straight from the browser's file picker, with no `id`/`url` (nothing
+      // was uploaded anywhere) — meant to feed a `callApi` action's
+      // `multipart: true` body (see that handler's own doc comment), the
+      // real fix for the disclosed "core.file-upload cannot emit raw bytes
+      // into a callApi body" gap (`ai/patterns/import.md`).
+      name: "mode",
+      type: "string",
+      sources: ["static"],
+      default: "dms",
+      constraints: {
+        options: [
+          { value: "dms", labelKey: "core.file-upload.mode.dms" },
+          { value: "raw", labelKey: "core.file-upload.mode.raw" }
+        ]
+      },
+      designer: { group: "behavior", editor: "select", labelKey: "core.file-upload.property.mode" }
     }
   ],
   outputs: [{ name: "value", type: "json" }],
@@ -14323,15 +14462,23 @@ var fileUploadDefinition = definition({
     category: "input",
     propertyGroups: [
       { id: "data", titleKey: "core.designer.group.data" },
-      { id: "content", titleKey: "core.designer.group.content" }
+      { id: "content", titleKey: "core.designer.group.content" },
+      { id: "behavior", titleKey: "core.designer.group.behavior" }
     ],
     allowedTargets: ["page", "form", "container", "dashboard"],
     preview: { kind: "field" }
   }
 });
+var rawFileIdCounter = 0;
+function nextRawFileId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  rawFileIdCounter += 1;
+  return `raw-file-${Date.now()}-${rawFileIdCounter}`;
+}
 function createFileUploadLogic(uploadSource) {
   return {
     render(io) {
+      const mode = io.props["mode"] === "raw" ? "raw" : "dms";
       const files = Array.isArray(io.props["value"]) ? io.props["value"] : [];
       const accept = typeof io.props["accept"] === "string" ? io.props["accept"] : void 0;
       const multiple = io.props["multiple"] !== false;
@@ -14340,8 +14487,17 @@ function createFileUploadLogic(uploadSource) {
         props: { value: files, accept, multiple },
         handlers: {
           upload: async (payload) => {
-            if (!uploadSource) return;
             const incoming = payload ?? [];
+            if (mode === "raw") {
+              await io.runLoading(async () => {
+                const picked = incoming.map((f) => ({ id: nextRawFileId(), ...f }));
+                const next = [...files, ...picked];
+                await io.writeOutput("value", next);
+                await io.emit("committed", { field: "value", old: files, new: next });
+              });
+              return;
+            }
+            if (!uploadSource) return;
             await io.runLoading(async () => {
               const uploaded = [];
               for (const f of incoming) uploaded.push(await uploadSource.upload(f, cabinetId));
@@ -18681,6 +18837,7 @@ async function applyRuleBindings(definition2, changedField, options) {
         continue;
       }
       mergeBlockEntry(options.scopes, "fieldOptions", rule.targetId, result);
+      options.scopes.set("form", `__fieldOptions.${rule.targetId}`, result);
       let optionsReset = false;
       if (rule.resetOnChange) {
         const current2 = options.scopes.values("form")[rule.targetId];
@@ -18963,7 +19120,7 @@ var FormPermissionEvaluator = class {
     return this.base.masked(subject) || this.staticSurface(subject.instanceId).masked;
   }
 };
-function fieldProperties(field, value, blockDef) {
+function fieldProperties(field, value, blockDef, ctx, definition2) {
   const portName = blockDef.outputs?.[0]?.name ?? (blockDef.type === "core.label" ? "text" : "value");
   const props = { [portName]: value };
   const c2 = field.constraints;
@@ -18979,7 +19136,13 @@ function fieldProperties(field, value, blockDef) {
     maybe("icon", c2.icon);
     maybe("revealToggle", c2.revealToggle);
     if (c2.options && blockDef.properties.some((p) => p.name === "options")) {
-      props["options"] = { source: "static", value: c2.options };
+      const dynamicRule = (definition2.rules ?? []).find((r) => r.output === "options" && r.targetKind === "field" && r.targetId === field.name);
+      if (dynamicRule) {
+        ctx.scopes.set("form", `__fieldOptions.${field.name}`, jsToRuntimeValue(c2.options));
+        props["options"] = { source: "binding", binding: { scope: "form", key: `__fieldOptions.${field.name}` } };
+      } else {
+        props["options"] = { source: "static", value: c2.options };
+      }
     }
   }
   return props;
@@ -18989,7 +19152,7 @@ function fieldOutputs(field, blockDef) {
   const portName = blockDef.outputs?.[0]?.name;
   return portName ? { [portName]: { scope: "form", key: field.name } } : void 0;
 }
-async function mountField(field, ctx, registry) {
+async function mountField(field, ctx, registry, definition2) {
   const blockType = field.kind === "computed" ? "core.label" : field.blockType;
   if (!blockType) {
     return { ok: false, diagnostics: [formDiagnostic("unknown-field", `Field "${field.name}" declares no blockType`, { path: field.name })] };
@@ -19007,7 +19170,7 @@ async function mountField(field, ctx, registry) {
     instanceId: field.name,
     blockType,
     blockVersion: registered.definition.version,
-    properties: fieldProperties(field, value, registered.definition),
+    properties: fieldProperties(field, value, registered.definition, ctx, definition2),
     outputs: fieldOutputs(field, registered.definition),
     // W10: the authored labelKey becomes the instance's accessible name,
     // resolved per locale by the runtime i18n resolver at render.
@@ -19111,7 +19274,7 @@ async function mountForm(options) {
   const fieldInstances = /* @__PURE__ */ new Map();
   const diagnostics = [];
   for (const field of options.definition.fields) {
-    const result = field.kind === "child-table" ? await mountChildTable(field, rootCtx, options.blockRegistry) : await mountField(field, rootCtx, options.blockRegistry);
+    const result = field.kind === "child-table" ? await mountChildTable(field, rootCtx, options.blockRegistry) : await mountField(field, rootCtx, options.blockRegistry, options.definition);
     if (!result.ok) {
       diagnostics.push(...result.diagnostics);
       continue;
@@ -19180,6 +19343,8 @@ var FormInstance = class {
     const result = await openForm(this.definition, this.instanceConfig, this.lifecycleOptions());
     this.subscription = this.bus.subscribe(this.tenantId, "ValueCommitted", (e) => this.onValueCommitted(e));
     this.lastSaved = snapshotFormValues(this.scopes);
+    const { effects } = await applyRuleBindings(this.definition, "onLoad", { tenantId: this.tenantId, scopes: this.scopes });
+    await Promise.all(effects.filter((e) => e.targetKind === "field").map((e) => this.fieldInstances.get(e.targetId)?.refresh()));
     this.present();
     return result;
   }
@@ -20244,7 +20409,7 @@ function resolveVariant(definition2, context) {
   }
   return { variantId: void 0, template: definition2.template, slotFills: definition2.slotFills, rows: definition2.rows };
 }
-var XS_BASE = { span: void 0, width: void 0, height: void 0, fontSize: void 0, spacing: void 0 };
+var XS_BASE = { span: void 0, offset: void 0, width: void 0, height: void 0, fontSize: void 0, spacing: void 0 };
 function resolveBreakpoint(breakpoints, target, hiddenAtXs) {
   const targetIndex = BREAKPOINTS2.indexOf(target);
   let resolved = { ...XS_BASE, hidden: hiddenAtXs ?? false };
@@ -20254,6 +20419,7 @@ function resolveBreakpoint(breakpoints, target, hiddenAtXs) {
     if (!override) continue;
     if (override.hidden !== void 0) resolved = { ...resolved, hidden: override.hidden };
     if (override.span !== void 0) resolved = { ...resolved, span: override.span };
+    if (override.offset !== void 0) resolved = { ...resolved, offset: override.offset };
     if (override.width !== void 0) resolved = { ...resolved, width: override.width };
     if (override.height !== void 0) resolved = { ...resolved, height: override.height };
     if (override.fontSize !== void 0) resolved = { ...resolved, fontSize: override.fontSize };
@@ -20642,7 +20808,8 @@ async function mountPage(options) {
     rows: mountedRows,
     overlays: options.definition.overlays ?? [],
     wizardSteps: wizardSteps === void 0 ? void 0 : mountedSteps,
-    canvasItems: mountedCanvasItems
+    canvasItems: mountedCanvasItems,
+    disableEmptyCollapse: options.disableEmptyCollapse
   });
   await instance.open();
   currentPageByRegistry.set(options.actionRegistry, instance);
@@ -20663,6 +20830,7 @@ var PageInstance = class {
   overlays = /* @__PURE__ */ new Map();
   wizardSteps;
   canvasItems;
+  disableEmptyCollapse;
   wizardStep = 0;
   openCounter = 0;
   rowVisible = /* @__PURE__ */ new Map();
@@ -20685,6 +20853,7 @@ var PageInstance = class {
     }
     this.wizardSteps = options.wizardSteps;
     this.canvasItems = options.canvasItems;
+    this.disableEmptyCollapse = options.disableEmptyCollapse ?? false;
   }
   get pageId() {
     return this.ctx.pageId;
@@ -20714,6 +20883,34 @@ var PageInstance = class {
       this.consumeOverlayIntent();
       void this.evaluateVisibility();
     });
+    await this.fireOnLoad();
+  }
+  /**
+   * Page-level `onLoad` (2026-09-22, 12-Column spec §23 gap-closing pass) —
+   * fires once, after the page's own content has mounted and its first
+   * visibility pass has run (so an `onLoad` action's `setValue`s land on a
+   * page whose rows/columns/items already exist to react to them). Mirrors
+   * `runLifecycleHook`'s own `onLoad` branch in `@erp/form-engine` — same
+   * `executeChain` call, same "fire and forget, never a page-open blocker"
+   * posture: a failing/invalid onLoad chain is logged to the console and
+   * swallowed, never thrown back into `mountPage`'s caller — an author
+   * mistake in a page-level hook must not take the whole page down the way
+   * one bad block instance already doesn't (see the diagnostics-collection
+   * loop in `mountPage` above).
+   */
+  async fireOnLoad() {
+    const binding = this.definition.events?.find((e) => e.hook === "onLoad");
+    if (!binding || binding.actions.length === 0) return;
+    try {
+      await executeChain(binding.actions, {
+        tenantId: this.ctx.tenantId,
+        registry: this.deps.actionRegistry,
+        scopes: this.ctx.scopes,
+        resolveConnection: this.ctx.resolveConnection
+      });
+    } catch (e) {
+      console.error(`Page "${this.definition.id}" onLoad action chain failed:`, e);
+    }
   }
   /**
    * Overlay intents (2026-07-16 audit): the Phase 2 `openDialog`/`closeDialog`
@@ -20809,11 +21006,12 @@ var PageInstance = class {
       `page-${this.pageId}`
     );
   }
-  /** Empty-region collapse (W2-03, gap 5): a column with no currently-visible items emits no node at all. */
-  columnNode(mountedColumn, rowAlign) {
+  /** Empty-region collapse (W2-03, gap 5): a column with no currently-visible items emits no node at all — skipped when `disableEmptyCollapse` is set (see that option's own doc comment). */
+  columnNode(mountedColumn, rowAlign, rowLayout) {
     if (this.columnVisible.get(mountedColumn.column.id) === false) return void 0;
     const itemNodes = mountedColumn.items.filter((i) => this.itemVisible.get(i.item.id) !== false).map((i) => this.itemNode(i));
-    if (isEmptyContainer(itemNodes.map(() => true))) return void 0;
+    const empty = isEmptyContainer(itemNodes.map(() => true));
+    if (empty && !this.disableEmptyCollapse) return void 0;
     return node("container", `${mountedColumn.column.id}-wrapper`, {
       props: {
         pageLayoutRole: "column",
@@ -20821,20 +21019,25 @@ var PageInstance = class {
         hiddenAtXs: mountedColumn.column.hiddenAtXs,
         spanAtXs: mountedColumn.column.spanAtXs,
         card: mountedColumn.column.card,
+        style: mountedColumn.column.style,
         align: rowAlign,
-        widthOverride: this.columnWidth.get(mountedColumn.column.id)
+        rowLayout,
+        widthOverride: this.columnWidth.get(mountedColumn.column.id),
+        // Only ever true when `disableEmptyCollapse` kept an otherwise-collapsed column alive — the render
+        // adapter's own signal to show a real "drop a component here" placeholder instead of a blank box.
+        emptyPlaceholder: empty && this.disableEmptyCollapse
       },
       children: itemNodes
     });
   }
-  /** Empty-region collapse (W2-03, gap 5): a row whose every column collapsed emits no node at all — proven on xs-stacked layout where an empty row would otherwise be a visible hole. */
+  /** Empty-region collapse (W2-03, gap 5): a row whose every column collapsed emits no node at all — proven on xs-stacked layout where an empty row would otherwise be a visible hole; skipped when `disableEmptyCollapse` is set. */
   rowNode(mountedRow) {
     if (!mountedRow.activated) {
       return node("skeleton", `${mountedRow.row.id}-deferred`, { a11y: { role: "status" } });
     }
     if (this.rowVisible.get(mountedRow.row.id) === false) return void 0;
-    const columnNodes = mountedRow.columns.map((c2) => this.columnNode(c2, mountedRow.row.align)).filter((n) => n !== void 0);
-    if (isEmptyContainer(columnNodes.map(() => true))) return void 0;
+    const columnNodes = mountedRow.columns.map((c2) => this.columnNode(c2, mountedRow.row.align, mountedRow.row.layout)).filter((n) => n !== void 0);
+    if (isEmptyContainer(columnNodes.map(() => true)) && !this.disableEmptyCollapse) return void 0;
     return node("container", `${mountedRow.row.id}-wrapper`, {
       props: {
         pageLayoutRole: "row",
@@ -20842,7 +21045,9 @@ var PageInstance = class {
         hiddenAtXs: mountedRow.row.hiddenAtXs,
         align: mountedRow.row.align,
         edgeSpacing: mountedRow.row.edgeSpacing,
-        sticky: mountedRow.row.sticky
+        sticky: mountedRow.row.sticky,
+        style: mountedRow.row.style,
+        layout: mountedRow.row.layout
       },
       children: columnNodes
     });

package/erp-cli/authoring-root.mjs

@@ -246,7 +246,18 @@ export function docsSearchRoots() {
     if (existsSync(bun)) roots.push({ dir: bun, source: "developer-docs (bundled)", relBase: bun });
     return roots;
   }
-  return [{ dir: path.join(REPO_ROOT, "ai"), source: "ai/domains doc", relBase: REPO_ROOT }];
+  // Monorepo mode — real bug found 2026-09-22: this used to return ONLY
+  // ai/, so every developer-docs/ page (the actual tenant-facing content —
+  // what the SDK bundle ships, what erp docs search's own packaged-mode
+  // branch above searches) was invisible to `erp docs search`/MCP's
+  // `erp_search_docs` while working directly in this repo, the one place a
+  // platform contributor is most likely to be adding new pages. Both roots
+  // now included; developer-docs/ first since it's the tenant-facing
+  // surface this tool exists to help developers not re-derive.
+  return [
+    { dir: path.join(REPO_ROOT, "developer-docs"), source: "developer-docs", relBase: REPO_ROOT },
+    { dir: path.join(REPO_ROOT, "ai"), source: "ai/domains doc", relBase: REPO_ROOT },
+  ];
 }
 
 /** backend/modules root for filename-substring example search. */