@pibbl/core 0.0.1 → 0.0.3-alpha.109.1

package/dist/lib/layout/measure.js

@@ -1,42 +1,421 @@
+import { bindCanvasMeasurementService, sameCanvasMeasurementService } from "./canvas-measurement.js";
+import { allocationMeasurement, declineUnrecordedAllocationMeasurement, declineUntracedAllocationQuery, allocationQueryReplayRevision, allocationQueryVolatilityRevision } from "./allocation-checkpoint.js";
+import { allocationOwner, setAllocationOwner } from "./allocation-revision.js";
+import { isFitContent } from "../style/sizing-length.js";
+import { observeReceiverInputReads, captureReceiverInputProvision, replayReceiverInputProvision, withReceiverInputProvision } from "../signals/input-provision.js";
+import { hasPercentageBoxPadding } from "./box-insets.js";
+import { contentBoxStyle } from "./box-sizing.js";
+import { isLayoutComponent, placedLayoutComponentRoot } from "./define-layout-component.js";
 import { getStyleMeasurementMode, withStyleMeasurement, rejectResponsiveMeasurement, UnsupportedResponsiveMeasurement } from "../style/responsive.js";
 import { layoutDiagnostic } from "../style/diagnostics.js";
 import { GLOBAL_STATE } from "../global-state.js";
+import { withMeasurementLayoutOwner } from "./wasm/region.js";
 import { EMPTY_STYLE } from "../style/empty-style.js";
 import {
   takePreNormalizedStyle,
+  peekPreNormalizedStyle,
   withoutSystemFilter
 } from "../style/resolve-dispatch.js";
 import {
   createPrimitiveReceiverToken,
   getPrimitiveDefinition,
+  getPrimitiveProgramProps,
   getPrimitiveReceiverToken,
-  getPolicyPreparationSource
+  getElementMetadata
 } from "../element/metadata.js";
 import { resolvePrimitiveInputs } from "../element/resolve-primitive-inputs.js";
 import { recordLayoutMeasurement } from "./diagnostics.js";
 import { prepareElementPolicies } from "../element/children.js";
-import { untracked, withSignalWriteForbidden } from "../signals/graph.js";
+import { isSignal, trackSignalDependency, withSignalTracking, withSignalDependencyRole, untracked, withSignalWriteForbidden } from "../signals/graph.js";
 function measureElement(element, constraints, service) {
+  const resolveService = bindCanvasMeasurementService(service);
+  return allocationMeasurement(element, (current) => measureElementUncached(current, constraints, resolveService()));
+}
+function measureElementUncached(element, constraints, service) {
   const context = {
     active: /* @__PURE__ */ new Set(),
     stack: []
   };
   const mode = getStyleMeasurementMode() ? "recursive" : GLOBAL_STATE.componentRefs ? "mounted-intrinsic" : "standalone-root";
-  return withSignalWriteForbidden(
+  const owner = GLOBAL_STATE.currentPibblInstance?.interactionRoot ?? GLOBAL_STATE.currentPibblInstance;
+  const evaluate = () => withSignalWriteForbidden(
     "Signal writes are forbidden during Pibbl measurement",
-    () => withStyleMeasurement(mode, () => withIsolatedRenderState(
+    () => withMeasurementLayoutOwner(owner, () => withStyleMeasurement(mode, () => withIsolatedRenderState(
       () => measureElementInternal(element, constraints, service, context)
-    ))
+    )))
   );
+  const receiver = getPrimitiveReceiverToken(element);
+  return receiver ? withReceiverInputProvision(GLOBAL_STATE.renderTransaction, receiver, () => withSignalDependencyRole("measurement", evaluate)) : evaluate();
+}
+function measurementDependenciesUnchanged(entry) {
+  const versions = entry.dependencyVersions;
+  if (!versions || versions.length !== entry.dependencies.length) return false;
+  for (let index = 0; index < versions.length; index++) {
+    const node = entry.dependencies[index];
+    node.validate?.();
+    if (node.version !== versions[index]) return false;
+  }
+  return true;
+}
+function measurementDependencyVersions(dependencies) {
+  const versions = [];
+  for (let index = 0; index < dependencies.length; index++) versions.push(dependencies[index].version);
+  return versions;
+}
+const intrinsicTransactions = /* @__PURE__ */ new WeakMap();
+function intrinsicInputSnapshot(element) {
+  const props = getPrimitiveProgramProps(element);
+  const style = peekPreNormalizedStyle(element)?.style;
+  const snapshot = [];
+  for (const key of Object.keys(props)) {
+    const value = props[key];
+    if (value !== null && (typeof value === "object" && !isSignal(value) || typeof value === "function")) return;
+    snapshot.push(key, value);
+  }
+  if (style) for (const key of Object.keys(style)) {
+    const value = style[key];
+    if (isFitContent(value) && Object.isFrozen(value)) {
+      snapshot.push(key, isFitContent, value.limit);
+      continue;
+    }
+    if (value !== null && (typeof value === "object" || typeof value === "function")) return;
+    snapshot.push(key, value);
+  }
+  return snapshot;
+}
+function sameIntrinsicInputs(left, right) {
+  if (!left || !right || left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index++) if (!Object.is(left[index], right[index])) return false;
+  return true;
+}
+function measureIntrinsicElement(element, constraints, service, options) {
+  const resolveService = bindCanvasMeasurementService(service);
+  return allocationMeasurement(element, (current) => measurePrimitiveInput(current, constraints, resolveService(), true, options));
+}
+function measureConstrainedIntrinsicElement(element, constraints, service, options) {
+  const resolveService = bindCanvasMeasurementService(service);
+  return allocationMeasurement(element, (current) => measurePrimitiveInput(current, constraints, resolveService(), false, options));
+}
+function measurePreparedLayoutElement(element, constraints, service, options, snapshot, receivers) {
+  declineUnrecordedAllocationMeasurement();
+  return measurePrimitiveInput(element, constraints, service, false, options, { snapshot, receivers });
+}
+const preparedBaselineOwners = /* @__PURE__ */ new WeakMap();
+function setPreparedBaselineOwner(element, owner) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const receiver = getPrimitiveReceiverToken(element);
+  const query = peekPreNormalizedStyle(element)?.query;
+  if (!transaction || !receiver || !query || !Number.isFinite(owner.width) || !Number.isFinite(owner.height) || query.basis.width !== owner.width || query.basis.height !== owner.height) return;
+  preparedBaselineOwners.set(element, { transaction, receiver, query, width: owner.width, height: owner.height });
+}
+function measureBaselineElement(element, allocation, service, options) {
+  const resolveService = bindCanvasMeasurementService(service);
+  const owner = preparedBaselineOwners.get(element);
+  const ownerValid = owner && owner.transaction === GLOBAL_STATE.renderTransaction && owner.receiver === getPrimitiveReceiverToken(element) && owner.query === peekPreNormalizedStyle(element)?.query;
+  const ownerBox = ownerValid ? { x: 0, y: 0, width: owner.width, height: owner.height } : void 0;
+  return allocationMeasurement(element, (current) => {
+    if (ownerBox) setPreparedBaselineOwner(current, ownerBox);
+    return measureBaselineElementUncached(current, allocation, resolveService(), options);
+  }, true);
+}
+function measureBaselineElementUncached(element, allocation, service, options) {
+  if (!options && !peekPreNormalizedStyle(element)?.query) {
+    const mode = getStyleMeasurementMode() ? "recursive" : GLOBAL_STATE.componentRefs ? "mounted-intrinsic" : "standalone-root";
+    return exactDirectMeasurement(
+      element,
+      service,
+      ["baseline", mode, allocation.width, allocation.height],
+      () => measureBaselineElementWithCache(element, allocation, service)
+    );
+  }
+  return measureBaselineElementWithCache(element, allocation, service, options);
+}
+function measureBaselineElementWithCache(element, allocation, service, options) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const receiver = getPrimitiveReceiverToken(element);
+  const mode = getStyleMeasurementMode() ? "recursive" : GLOBAL_STATE.componentRefs ? "mounted-intrinsic" : "standalone-root";
+  const key = `baseline:${options?.key ?? ""}`;
+  const constraints = {
+    minWidth: allocation.width,
+    maxWidth: allocation.width,
+    minHeight: allocation.height,
+    maxHeight: allocation.height
+  };
+  return withSignalWriteForbidden("Signal writes are forbidden during Pibbl measurement", () => withReceiverInputProvision(transaction, receiver, () => withSignalDependencyRole("measurement", () => {
+    const source = options?.source ?? element;
+    let inputSnapshot = intrinsicInputSnapshot(element);
+    if (source !== element) {
+      const sourceSnapshot = intrinsicInputSnapshot(source);
+      if (!sourceSnapshot || !inputSnapshot) inputSnapshot = void 0;
+      else {
+        sourceSnapshot.push(source.type, source.key, element.type, element.key, inputSnapshot.length);
+        for (let index = 0; index < inputSnapshot.length; index++) sourceSnapshot.push(inputSnapshot[index]);
+        inputSnapshot = sourceSnapshot;
+      }
+    }
+    let receivers = transaction && intrinsicTransactions.get(transaction);
+    let entries = options && receivers?.get(options.token);
+    let entry = options && (entries?.get(key) ?? options.cache.readPrimitiveMeasurement(options.token, key));
+    if (!entry || !measurementDependenciesUnchanged(entry) || entry.mode !== "baseline" || entry.props !== source.props || !sameIntrinsicInputs(entry.inputSnapshot, inputSnapshot)) {
+      options?.recordMeasurement();
+      const dependencies = [];
+      const addDependency = (node) => {
+        if (!dependencies.includes(node)) dependencies.push(node);
+      };
+      const result = observeReceiverInputReads(addDependency, () => withSignalTracking({ addDependency }, () => withStyleMeasurement(mode, () => withIsolatedRenderState(
+        () => measureBaselineInput(element, allocation, constraints, service)
+      ))));
+      entry = { props: source.props, key, result, mode: "baseline", dependencies, dependencyVersions: measurementDependencyVersions(dependencies), inputSnapshot };
+      if (options && transaction && inputSnapshot && result.status === "measured") {
+        if (!receivers) {
+          receivers = /* @__PURE__ */ new WeakMap();
+          intrinsicTransactions.set(transaction, receivers);
+        }
+        if (!entries) {
+          entries = /* @__PURE__ */ new Map();
+          receivers.set(options.token, entries);
+        }
+        entries.set(key, entry);
+        const snapshot = entry;
+        transaction.onFinish((success) => {
+          if (success) options.cache.writePrimitiveMeasurement(options.token, snapshot);
+        });
+      }
+    }
+    for (const node of entry.dependencies) trackSignalDependency(node, "measurement");
+    return entry.result;
+  })));
 }
-function measureElementInternal(element, constraints, service, context) {
+function measureBaselineInput(original, allocation, constraints, service) {
+  const element = prepareElementPolicies(original, "measureBaselines");
+  recordLayoutMeasurement();
+  const definition = getPrimitiveDefinition(element.type);
+  const component = element.type.name || "Anonymous";
+  if (isLayoutComponent(element.type)) {
+    return { status: "unsupported", reason: "baseline providers currently require a direct custom primitive" };
+  }
+  if (!definition?.measureBaselines) {
+    return { status: "unsupported", reason: `${component} does not provide baseline measurement` };
+  }
+  const preNormalized = takePreNormalizedStyle(element);
+  const preparedOwner = preparedBaselineOwners.get(element);
+  preparedBaselineOwners.delete(element);
+  if (preNormalized?.query && getStyleMeasurementMode() !== "standalone-root") {
+    const query = preNormalized.query;
+    if (getStyleMeasurementMode() !== "mounted-intrinsic" || !preparedOwner || preparedOwner.transaction !== GLOBAL_STATE.renderTransaction || preparedOwner.receiver !== getPrimitiveReceiverToken(element) || preparedOwner.query !== query || preparedOwner.width !== query.basis.width || preparedOwner.height !== query.basis.height) {
+      rejectResponsiveMeasurement(element);
+    }
+  }
+  const inputs = resolvePrimitiveInputs(element, definition, preNormalized, {
+    width: allocation.width,
+    height: allocation.height
+  });
+  const specifiedStyle = withoutSystemFilter(preNormalized?.style ?? inputs.style ?? EMPTY_STYLE);
+  let normalized = preNormalized ? specifiedStyle : definition.normalizeStyle ? definition.normalizeStyle(specifiedStyle) : specifiedStyle;
+  if (hasPercentageBoxPadding(normalized)) {
+    return { status: "unsupported", reason: "percentage padding requires an actual finite Flex owner allocation" };
+  }
+  if ("boxSizing" in normalized && normalized.boxSizing !== void 0) {
+    normalized = contentBoxStyle(normalized, {
+      width: allocation.width,
+      height: allocation.height,
+      context: { component, algorithm: "baseline measurement", constraints }
+    });
+  }
+  const previousReceiverToken = GLOBAL_STATE.primitiveReceiverToken;
+  GLOBAL_STATE.primitiveReceiverToken = getPrimitiveReceiverToken(element) ?? createPrimitiveReceiverToken();
+  try {
+    const result = definition.measureBaselines({
+      props: inputs.props,
+      style: normalized,
+      allocation: { x: 0, y: 0, width: allocation.width, height: allocation.height },
+      service
+    });
+    if (result.status === "unsupported") return result;
+    if (result.status !== "measured" || !Number.isFinite(result.first) || !Number.isFinite(result.last) || result.first > result.last) {
+      throw layoutDiagnostic({
+        component,
+        property: "measureBaselines",
+        value: result,
+        algorithm: "baseline measurement",
+        constraints,
+        reason: "first and last baselines must be finite with first not after last"
+      });
+    }
+    return { status: "measured", first: result.first, last: result.last };
+  } catch (error) {
+    if (error instanceof UnsupportedResponsiveMeasurement) return { status: "unsupported", reason: error.message };
+    throw error;
+  } finally {
+    GLOBAL_STATE.primitiveReceiverToken = previousReceiverToken;
+  }
+}
+function measurePrimitiveInput(element, constraints, service, intrinsic, options, prepared) {
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const receiver = getPrimitiveReceiverToken(element);
+  const context = { active: /* @__PURE__ */ new Set(), stack: [] };
+  const mode = getStyleMeasurementMode() ? "recursive" : GLOBAL_STATE.componentRefs ? "mounted-intrinsic" : "standalone-root";
+  const key = `${intrinsic ? "intrinsic" : "finite"}:${options?.key ?? ""}`;
+  const owner = GLOBAL_STATE.currentPibblInstance?.interactionRoot ?? GLOBAL_STATE.currentPibblInstance;
+  return withSignalWriteForbidden("Signal writes are forbidden during Pibbl measurement", () => withMeasurementLayoutOwner(owner, () => withReceiverInputProvision(transaction, receiver, () => withSignalDependencyRole("measurement", () => {
+    const inputSnapshot = prepared?.snapshot ?? intrinsicInputSnapshot(element);
+    let receivers = transaction && intrinsicTransactions.get(transaction);
+    let entries = options && receivers?.get(options.token);
+    let entry = options && (entries?.get(key) ?? options.cache.readPrimitiveMeasurement(options.token, key));
+    const entryMode = intrinsic ? "intrinsic" : "finite";
+    if (!entry || !measurementDependenciesUnchanged(entry) || entry.mode !== entryMode || entry.props !== element.props || !sameIntrinsicInputs(entry.inputSnapshot, inputSnapshot) || prepared && entry.receiverReceipts === void 0) {
+      options?.recordMeasurement();
+      const dependencies = [];
+      const receiverDependencies = [];
+      let untracedReceiverReads = false;
+      const trace = prepared ? {
+        cacheable: true,
+        receipts: [],
+        receivers: prepared.receivers
+      } : void 0;
+      const evaluate = () => withStyleMeasurement(mode, () => withIsolatedRenderState(
+        () => intrinsic ? measureElementInternal(element, constraints, service, context, true) : measureElementInternal(element, constraints, service, context, false, true)
+      ));
+      const addDependency = (node) => {
+        if (!dependencies.includes(node)) dependencies.push(node);
+        if (!receiverDependencies.includes(node)) receiverDependencies.push(node);
+      };
+      const result = observeReceiverInputReads((node, _roles, inputReceiver) => {
+        if (!dependencies.includes(node)) dependencies.push(node);
+        if (inputReceiver === receiver && !receiverDependencies.includes(node)) receiverDependencies.push(node);
+        if (inputReceiver !== receiver && !trace) untracedReceiverReads = true;
+      }, () => withSignalTracking({ addDependency }, () => trace ? withConstrainedMeasurementTrace(trace, evaluate) : evaluate()));
+      entry = {
+        props: element.props,
+        key,
+        result,
+        mode: entryMode,
+        dependencies,
+        receiverDependencies,
+        dependencyVersions: measurementDependencyVersions(dependencies),
+        inputSnapshot,
+        ...trace?.cacheable ? { receiverReceipts: trace.receipts } : {}
+      };
+      if (options && transaction && inputSnapshot && result.status === "measured" && !untracedReceiverReads && (!trace || trace.cacheable)) {
+        if (!receivers) {
+          receivers = /* @__PURE__ */ new WeakMap();
+          intrinsicTransactions.set(transaction, receivers);
+        }
+        if (!entries) {
+          entries = /* @__PURE__ */ new Map();
+          receivers.set(options.token, entries);
+        }
+        entries.set(key, entry);
+        const snapshot = entry;
+        transaction.onFinish((success) => {
+          if (success) options.cache.writePrimitiveMeasurement(options.token, snapshot);
+        });
+      }
+    }
+    if (prepared && entry.receiverReceipts) {
+      for (let index = 0; index < entry.receiverReceipts.length; index++) {
+        const captured = entry.receiverReceipts[index];
+        replayReceiverInputProvision(transaction, prepared.receivers[captured.childIndex], captured.receipt);
+      }
+    }
+    for (const node of entry.receiverDependencies ?? entry.dependencies) trackSignalDependency(node, "measurement");
+    return entry.result;
+  }))));
+}
+let constrainedChildContext;
+let constrainedChildService;
+let constrainedMeasurementTrace;
+function withConstrainedMeasurementTrace(trace, work) {
+  const previous = constrainedMeasurementTrace;
+  constrainedMeasurementTrace = trace;
+  try {
+    return work();
+  } finally {
+    constrainedMeasurementTrace = previous;
+  }
+}
+const exactDirectDemands = /* @__PURE__ */ new WeakMap();
+function exactDirectMeasurement(element, service, key, run, allowHit = true) {
+  const transaction = GLOBAL_STATE.renderTransaction, receiver = getPrimitiveReceiverToken(element);
+  if (!transaction || !receiver || Object.hasOwn(element.props, "children") || isLayoutComponent(element.type)) return run();
+  const inputs = peekPreNormalizedStyle(element) ? intrinsicInputSnapshot(element) : void 0;
+  const demands = exactDirectDemands.get(transaction), prior = demands?.get(receiver);
+  if (allowHit && inputs && prior && prior.type === element.type && sameCanvasMeasurementService(prior.service, service) && sameIntrinsicInputs(prior.key, key) && sameIntrinsicInputs(prior.inputs, inputs) && measurementDependenciesUnchanged(prior)) {
+    takePreNormalizedStyle(element);
+    replayReceiverInputProvision(transaction, receiver, prior.receipt);
+    return prior.result;
+  }
+  let direct = true;
+  const receipt = [];
+  const replayRevision = allocationQueryReplayRevision(), volatility = allocationQueryVolatilityRevision();
+  const captured = observeReceiverInputReads((node, roles, owner) => {
+    if (owner !== receiver) {
+      direct = false;
+      return;
+    }
+    const existing = receipt.find((entry) => entry.node === node);
+    if (existing) existing.roles |= roles;
+    else receipt.push({ node, roles });
+  }, () => captureReceiverInputProvision(transaction, receiver, run));
+  if (inputs && direct && replayRevision === allocationQueryReplayRevision() && volatility === allocationQueryVolatilityRevision() && captured.receipt && captured.value.status === "measured") {
+    let current = demands;
+    if (!current) {
+      current = /* @__PURE__ */ new WeakMap();
+      exactDirectDemands.set(transaction, current);
+      transaction.onFinish(() => exactDirectDemands.delete(transaction));
+    }
+    const dependencies = receipt.map((entry) => entry.node);
+    current.set(receiver, {
+      type: element.type,
+      service,
+      key,
+      inputs,
+      receipt,
+      dependencies,
+      dependencyVersions: measurementDependencyVersions(dependencies),
+      result: captured.value
+    });
+  }
+  return captured.value;
+}
+function measureConstrainedLayoutChild(element, constraints, childIndex) {
+  const context = constrainedChildContext, service = constrainedChildService;
+  if (!context || !service) throw new Error("Constrained structural measurement requires an active provider measurement.");
+  const transaction = GLOBAL_STATE.renderTransaction;
+  const receiver = getPrimitiveReceiverToken(element);
+  const trace = constrainedMeasurementTrace;
+  const run = () => withSignalDependencyRole("measurement", () => measureElementInternal(element, constraints, service, context, false, true));
+  if (transaction && receiver && childIndex === void 0 && !Object.hasOwn(element.props, "children") && !isLayoutComponent(element.type)) {
+    if (trace) trace.cacheable = false;
+    const metadata = getElementMetadata(element);
+    const source = metadata?.policyPreparationSource ?? metadata?.layoutDescriptionSource ?? peekPreNormalizedStyle(element)?.source ?? element;
+    return exactDirectMeasurement(
+      element,
+      service,
+      ["size", getStyleMeasurementMode(), constraints.minWidth, constraints.maxWidth, constraints.minHeight, constraints.maxHeight],
+      run,
+      !context.active.has(source)
+    );
+  }
+  if (!trace) return withReceiverInputProvision(transaction, receiver, run);
+  if (childIndex === void 0 || trace.receivers[childIndex] !== receiver) {
+    trace.cacheable = false;
+    return withReceiverInputProvision(transaction, receiver, run);
+  }
+  const captured = captureReceiverInputProvision(transaction, receiver, run);
+  if (captured.receipt === void 0) trace.cacheable = false;
+  else trace.receipts.push({ childIndex, receipt: captured.receipt });
+  return captured.value;
+}
+function measureElementInternal(element, constraints, service, context, intrinsic = false, providerInputs = false) {
   element = prepareElementPolicies(element, "measureElement");
   recordLayoutMeasurement();
   const type = element.type;
   const definition = getPrimitiveDefinition(type);
   const component = type.name || "Anonymous";
   const preNormalized = takePreNormalizedStyle(element);
-  const source = getPolicyPreparationSource(element) ?? preNormalized?.source ?? element;
+  const metadata = getElementMetadata(element);
+  const source = metadata?.policyPreparationSource ?? metadata?.layoutDescriptionSource ?? preNormalized?.source ?? element;
   if (context.active.has(source)) {
     throw layoutDiagnostic({
       component,
@@ -47,10 +426,21 @@ function measureElementInternal(element, constraints, service, context) {
       reason: "cyclic measurement dependency is not supported"
     });
   }
-  if (!definition?.measure) {
+  if (isLayoutComponent(type)) {
+    context.active.add(source);
+    context.stack.push(element);
+    try {
+      const root = placedLayoutComponentRoot(element, preNormalized);
+      return withReceiverInputProvision(GLOBAL_STATE.renderTransaction, getPrimitiveReceiverToken(root), () => intrinsic ? measureElementInternal(root, constraints, service, context, true) : measureElementInternal(root, constraints, service, context, false, providerInputs));
+    } finally {
+      context.stack.pop();
+      context.active.delete(source);
+    }
+  }
+  if (intrinsic ? !definition?.measureIntrinsic : !definition?.measure) {
     return {
       status: "unsupported",
-      reason: `${component} does not provide measurement`
+      reason: `${component} does not provide ${intrinsic ? "intrinsic measurement" : "measurement"}`
     };
   }
   context.active.add(source);
@@ -59,29 +449,62 @@ function measureElementInternal(element, constraints, service, context) {
     if (preNormalized?.query && getStyleMeasurementMode() !== "standalone-root") {
       rejectResponsiveMeasurement(element);
     }
-    const inputs = untracked(() => resolvePrimitiveInputs(element, definition, preNormalized, {
+    const readInputs = () => resolvePrimitiveInputs(element, definition, preNormalized, {
       width: constraints.maxWidth,
       height: constraints.maxHeight
-    }));
+    });
+    const inputs = intrinsic || providerInputs ? readInputs() : untracked(readInputs);
     const specifiedStyle = withoutSystemFilter(
       preNormalized?.style ?? inputs.style ?? EMPTY_STYLE
     );
-    const normalized = preNormalized ? specifiedStyle : definition.normalizeStyle ? definition.normalizeStyle(specifiedStyle) : specifiedStyle;
+    let normalized = preNormalized ? specifiedStyle : definition.normalizeStyle ? definition.normalizeStyle(specifiedStyle) : specifiedStyle;
+    if (hasPercentageBoxPadding(normalized)) return { status: "unsupported", reason: "percentage padding requires an actual finite Flex owner allocation" };
+    if ("boxSizing" in normalized && normalized.boxSizing !== void 0) normalized = contentBoxStyle(normalized, { width: constraints.maxWidth, height: constraints.maxHeight, context: { component, algorithm: "measurement", constraints } });
     const previousReceiverToken = GLOBAL_STATE.primitiveReceiverToken;
     GLOBAL_STATE.primitiveReceiverToken = getPrimitiveReceiverToken(element) ?? createPrimitiveReceiverToken();
     let result;
+    const previousConstrainedChildContext = constrainedChildContext;
+    const previousConstrainedChildService = constrainedChildService;
+    if (!intrinsic) {
+      constrainedChildContext = context;
+      constrainedChildService = service;
+    }
     try {
-      result = withStyleMeasurement("recursive", () => definition.measure({
+      result = withStyleMeasurement("recursive", () => intrinsic ? definition.measureIntrinsic({
+        props: inputs.props,
+        style: normalized,
+        service,
+        constraints: {
+          width: Number.isFinite(constraints.maxWidth) ? { kind: "bounded", min: constraints.minWidth, max: constraints.maxWidth } : { kind: "unbounded", min: constraints.minWidth },
+          height: Number.isFinite(constraints.maxHeight) ? { kind: "bounded", min: constraints.minHeight, max: constraints.maxHeight } : { kind: "unbounded", min: constraints.minHeight }
+        }
+      }) : definition.measure({
         props: inputs.props,
         style: normalized,
         constraints,
         service,
-        measureElement: (child, childConstraints) => measureElementInternal(child, childConstraints, service, context)
+        measureElement: (child, childConstraints) => {
+          if (constrainedMeasurementTrace) constrainedMeasurementTrace.cacheable = false;
+          const receiver = getPrimitiveReceiverToken(child);
+          const prepared = peekPreNormalizedStyle(child);
+          if (!receiver || !prepared) declineUntracedAllocationQuery();
+          return receiver ? withReceiverInputProvision(GLOBAL_STATE.renderTransaction, receiver, () => withSignalDependencyRole("measurement", () => measureElementInternal(child, childConstraints, service, context, false, !!prepared))) : measureElementInternal(child, childConstraints, service, context);
+        }
       }));
     } finally {
+      constrainedChildContext = previousConstrainedChildContext;
+      constrainedChildService = previousConstrainedChildService;
       GLOBAL_STATE.primitiveReceiverToken = previousReceiverToken;
     }
     if (result.status === "unsupported") return result;
+    if ("minContent" in result) {
+      validateMeasuredSize(result.minContent.width, "minContent.width", component, constraints);
+      validateMeasuredSize(result.minContent.height, "minContent.height", component, constraints);
+      validateMeasuredSize(result.maxContent.width, "maxContent.width", component, constraints);
+      validateMeasuredSize(result.maxContent.height, "maxContent.height", component, constraints);
+      if (result.minContent.width > result.maxContent.width) throw layoutDiagnostic({ component, property: "measureIntrinsic", value: result, algorithm: "measurement", constraints, reason: "min-content width must not exceed max-content width" });
+      return result;
+    }
     validateMeasuredSize(result.size.width, "width", component, constraints);
     validateMeasuredSize(result.size.height, "height", component, constraints);
     return result;
@@ -96,6 +519,7 @@ function measureElementInternal(element, constraints, service, context) {
   }
 }
 function withIsolatedRenderState(work) {
+  const previousAllocationOwner = setAllocationOwner(allocationOwner());
   const snapshot = {
     currentPibblInstance: GLOBAL_STATE.currentPibblInstance,
     componentRefs: GLOBAL_STATE.componentRefs,
@@ -124,6 +548,7 @@ function withIsolatedRenderState(work) {
     return work();
   } finally {
     Object.assign(GLOBAL_STATE, snapshot);
+    setAllocationOwner(previousAllocationOwner);
   }
 }
 function validateMeasuredSize(value, property, component, constraints) {
@@ -139,6 +564,14 @@ function validateMeasuredSize(value, property, component, constraints) {
   }
 }
 export {
-  measureElement
+  measureBaselineElement,
+  measureConstrainedIntrinsicElement,
+  measureConstrainedLayoutChild,
+  measureElement,
+  measureIntrinsicElement,
+  measurePreparedLayoutElement,
+  setPreparedBaselineOwner,
+  withConstrainedMeasurementTrace,
+  withIsolatedRenderState
 };
 //# sourceMappingURL=measure.js.map