@tileflow/core 0.1.0-alpha.37 → 0.1.0-alpha.38

package/dist/index.js

@@ -850,8 +850,11 @@ var init_time_of_day = __esm({
 });
 
 // src/themes/visual-semantics.ts
+function isTileflowVisualColorCollection(property) {
+  return property === "colors" || property.endsWith("Colors") || property.endsWith("-colors");
+}
 function classifyTileflowVisualProperty(property, _value) {
-  if (property === "color" || property === "colors" || property.endsWith("Color") || property.endsWith("Colors") || property.endsWith("-color") || property.endsWith("-colors")) {
+  if (property === "color" || property.endsWith("Color") || property.endsWith("-color") || isTileflowVisualColorCollection(property)) {
     return "color";
   }
   if (property === "font" || property === "fallbacks" || property.endsWith("-font")) return "font";
@@ -1218,15 +1221,19 @@ function visitAuditableValue(value, path, category, state, intentRequired = fals
     }
     return;
   }
+  const collectionCategory = isTileflowVisualColorCollection(lastPathKey(path)) ? category : void 0;
   for (const key of Object.keys(value).sort(compareCodeUnits2)) {
     visitAuditableValue(
       value[key],
       `${path}.${key}`,
-      classifyTileflowVisualProperty(key, value[key]),
+      classifyTileflowVisualProperty(key, value[key]) ?? collectionCategory,
       state
     );
   }
 }
+function lastPathKey(path) {
+  return path.endsWith("]") ? "" : path.slice(path.lastIndexOf(".") + 1);
+}
 function visitAuditableArray(value, path, category, state, forceExpression = false, intentRequired = false) {
   const operator = typeof value[0] === "string" ? value[0] : void 0;
   const isExpression = forceExpression || isMapLibreExpressionOperator(operator);
@@ -3655,6 +3662,7 @@ function readTileflowBuildings3D(metadata) {
     ...floodLight ? { floodLight } : {},
     ...modelLighting ? { modelLighting } : {},
     windows: value.windows === true,
+    ...readTileflowBuildingsEntrance(value.entrance),
     shadows: typeof value.shadows === "boolean" ? value.shadows : defaults4.shadows,
     occlusion: typeof value.occlusion === "boolean" ? value.occlusion : defaults4.occlusion,
     modelOcclusion: within(value.modelOcclusion, 1, defaults4.modelOcclusion),
@@ -3663,6 +3671,13 @@ function readTileflowBuildings3D(metadata) {
     ...landmarksOf(value.landmarks)
   };
 }
+function readTileflowBuildingsEntrance(value) {
+  if (!isRecord(value)) return {};
+  const band = (entry) => Array.isArray(entry) && entry.length === 2 && entry.every((zoom3) => typeof zoom3 === "number" && zoom3 >= 0 && zoom3 <= 24) && entry[0] < entry[1] ? [entry[0], entry[1]] : void 0;
+  const buildings2 = band(value.buildings);
+  const models = band(value.models);
+  return buildings2 || models ? { entrance: { ...buildings2 ? { buildings: buildings2 } : {}, ...models ? { models } : {} } } : {};
+}
 var modelId = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 var tileflowBuildingModelPlacementLimit = 256;
 var teamModelPrefix = "tileflow://team-models/";
@@ -3872,6 +3887,7 @@ function tileflowWorldV1Schema(options = {}) {
       sidewalk: "sidewalk",
       streetFurniture: "street_furniture",
       trafficControl: "traffic_control",
+      transportationOutline: "transportation_outline",
       ...options.layers
     },
     semantics: { ...options.semantics, parkLayer: "protected-only" }
@@ -3891,6 +3907,11 @@ function validateTileflowWorldV1Tilejson(tilejson, schema = tileflowWorldV1Schem
   const roadShield = requireTilejsonLayer(layers2, schema.layers.roadShield, issues);
   const canopy = optionalTilejsonLayer(layers2, schema.layers.canopy, issues);
   const trafficControl = optionalTilejsonLayer(layers2, schema.layers.trafficControl, issues);
+  const transportationOutline = requireTilejsonLayer(
+    layers2,
+    schema.layers.transportationOutline,
+    issues
+  );
   if (bathymetry2) {
     if (bathymetry2.minzoom !== 0 || bathymetry2.maxzoom !== 9) {
       issues.push(`Tileflow World V1 ${schema.layers.bathymetry} must declare z0-z9.`);
@@ -4081,6 +4102,27 @@ function validateTileflowWorldV1Tilejson(tilejson, schema = tileflowWorldV1Schem
       requireTilejsonField(canopy, schema.layers.canopy, field2, ["Number"], issues);
     }
   }
+  if (transportationOutline) {
+    if (transportationOutline.minzoom !== 13 || transportationOutline.maxzoom !== 15) {
+      issues.push(
+        `Tileflow World V1 ${schema.layers.transportationOutline} must declare native z13-z15.`
+      );
+    }
+    requireTilejsonField(
+      transportationOutline,
+      schema.layers.transportationOutline,
+      schema.fields.class,
+      ["String"],
+      issues
+    );
+    requireTilejsonField(
+      transportationOutline,
+      schema.layers.transportationOutline,
+      schema.fields.subclass,
+      ["String"],
+      issues
+    );
+  }
   return issues;
 }
 function requireTilejsonLayer(layers2, id2, issues) {
@@ -5045,7 +5087,7 @@ function applyLineStyle(layer, style) {
   const layout = { ...asRecord2(layer.layout) };
   setPaint(paint, "line-blur", style.blur);
   setPaint(paint, "line-color", style.color);
-  setPaint(paint, "line-dasharray", style.dash);
+  if (!isSolidDash(style.dash)) setPaint(paint, "line-dasharray", style.dash);
   setPaint(paint, "line-gap-width", style.gapWidth);
   setPaint(paint, "line-offset", style.offset);
   setPaint(paint, "line-opacity", style.opacity);
@@ -5289,6 +5331,12 @@ function withoutGovernedAllowOverlap(layout) {
   }
   return result;
 }
+function isSolidDash(value) {
+  if (value === void 0) return false;
+  const dash = toMapLibreStyleValue(value);
+  const array = Array.isArray(dash) && dash[0] === "literal" ? dash[1] : dash;
+  return Array.isArray(array) && array.length === 2 && array[0] === 1 && array[1] === 0;
+}
 function setPaint(paint, property, value) {
   if (value !== void 0) paint[property] = toMapLibreStyleValue(value);
 }
@@ -5816,6 +5864,21 @@ function compileBuildings(request, context) {
   }
   return contributions;
 }
+var buildingTargetsByMode = {
+  flat: ["buildings.flat.fill", "buildings.flat.outline"],
+  "3d": ["buildings.extrusion"]
+};
+function buildingTargetsOfOtherModes(request) {
+  const activeMode = request?.mode ?? "flat";
+  const targets = /* @__PURE__ */ new Map();
+  for (const [mode, modeTargets] of Object.entries(buildingTargetsByMode)) {
+    if (mode === activeMode) continue;
+    for (const target of modeTargets) {
+      targets.set(target, { activeMode, mode, owner: "buildings" });
+    }
+  }
+  return targets;
+}
 function buildingColorExpression(context) {
   const fields2 = context.data.schema.fields;
   const colors = context.colors.buildings;
@@ -5933,29 +5996,23 @@ function isTileflowPathRoadClass(roadClass) {
   return tileflowPathRoadClasses.includes(roadClass);
 }
 function tileflowRoadClassFilter(fields2, roadClass) {
+  const classes = tileflowRoadClassValues(roadClass);
   if (isTileflowPathRoadClass(roadClass)) {
     return [
       "all",
-      ["match", ["get", fields2.class], ["path", ...constructionClasses[roadClass]], true, false],
+      ["match", ["get", fields2.class], classes, true, false],
       ["match", ["get", fields2.subclass], pathSubclasses[roadClass], true, false]
     ];
   }
-  const classes = roadClass === "minor" ? [
-    "minor",
-    "residential",
-    "unclassified",
-    ...compatibleRoadClasses[roadClass] ?? [],
-    ...constructionClasses[roadClass]
-  ] : roadClass === "service" ? [
-    "service",
-    ...compatibleRoadClasses[roadClass] ?? [],
-    ...constructionClasses[roadClass]
-  ] : [
-    roadClass,
+  return ["match", ["get", fields2.class], classes, true, false];
+}
+function tileflowRoadClassValues(roadClass) {
+  if (isTileflowPathRoadClass(roadClass)) return ["path", ...constructionClasses[roadClass]];
+  return [
+    ...roadClass === "minor" ? ["minor", "residential", "unclassified"] : [roadClass],
     ...compatibleRoadClasses[roadClass] ?? [],
     ...constructionClasses[roadClass]
   ];
-  return ["match", ["get", fields2.class], classes, true, false];
 }
 
 // src/modules/roads/index.ts
@@ -9689,35 +9746,37 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     }),
     0
   ) : atZoom(borderWidth, level);
-  const geometry = (casing, width) => expression([
-    "interpolate",
-    ["exponential", 2],
-    ["zoom"],
-    ...geometryLevels.flatMap((level) => {
-      const centerline = ["*", radiusAt15, 2 ** (level - 15)];
-      const fallback = fallbackWidth === void 0 ? select(
-        widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
-        0
-      ) : atZoom(fallbackWidth, level);
-      const inner = [
-        "case",
-        physical,
-        ["*", centerline, ["/", innerMeters, radiusMeters]],
-        ["-", centerline, ["/", fallback, 2]]
-      ];
-      const fillWidth = [
-        "case",
-        physical,
-        ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
-        fallback
-      ];
-      const border = casing ? borderAt(level) : 0;
-      return [
-        level,
-        width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
-      ];
-    })
-  ]);
+  const geometry = (casing, width) => expression(
+    bindRepeated([
+      "interpolate",
+      ["exponential", 2],
+      ["zoom"],
+      ...geometryLevels.flatMap((level) => {
+        const centerline = ["*", radiusAt15, 2 ** (level - 15)];
+        const fallback = fallbackWidth === void 0 ? select(
+          widths.map(({ condition, value }) => ({ condition, value: atZoom(value, level) })),
+          0
+        ) : atZoom(fallbackWidth, level);
+        const inner = [
+          "case",
+          physical,
+          ["*", centerline, ["/", innerMeters, radiusMeters]],
+          ["-", centerline, ["/", fallback, 2]]
+        ];
+        const fillWidth = [
+          "case",
+          physical,
+          ["*", centerline, ["/", ["-", outerMeters, innerMeters], radiusMeters]],
+          fallback
+        ];
+        const border = casing ? borderAt(level) : 0;
+        return [
+          level,
+          width ? ["max", 0, ["+", fillWidth, border]] : ["max", 0, ["-", inner, ["/", border, 2]]]
+        ];
+      })
+    ])
+  );
   const phaseStyle = (phase) => ({
     color: "rgba(0, 0, 0, 0)",
     minZoom: 15,
@@ -9774,6 +9833,63 @@ function compileRoundabouts(request, surfaces, context, contributions) {
     });
   }
 }
+var bindable = /* @__PURE__ */ new Set([
+  "case",
+  "match",
+  "all",
+  "any",
+  "!",
+  "==",
+  "!=",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "has",
+  "get",
+  "to-number",
+  "coalesce",
+  "+",
+  "-",
+  "*",
+  "/",
+  "max",
+  "min"
+]);
+function bindRepeated(curve) {
+  let tree = curve;
+  for (let index = 0; index < 2; index += 1) {
+    const json = /* @__PURE__ */ new Map();
+    const found = /* @__PURE__ */ new Map();
+    const visit = (value) => {
+      if (!Array.isArray(value) || value[0] === "literal")
+        return { text: JSON.stringify(value), free: true };
+      const parts = value.map(visit);
+      const text = `[${parts.map((part) => part.text).join(",")}]`;
+      json.set(value, text);
+      const free = value[0] !== "zoom" && value[0] !== "var" && parts.every((part) => part.free);
+      if (free && typeof value[0] === "string" && bindable.has(value[0]))
+        found.set(text, (found.get(text) ?? 0) + 1);
+      return { text, free };
+    };
+    visit(tree);
+    let best;
+    let saving = 256;
+    for (const [text, count] of found) {
+      const saved = (count - 1) * text.length;
+      if (count > 1 && saved > saving) [best, saving] = [text, saved];
+    }
+    if (best === void 0) break;
+    const name = `tileflow_${index}`;
+    const replace = (value) => {
+      if (!Array.isArray(value) || value[0] === "literal") return value;
+      if (json.get(value) === best) return ["var", name];
+      return value.map(replace);
+    };
+    tree = ["let", name, JSON.parse(best), replace(tree)];
+  }
+  return tree;
+}
 function select(values, fallback) {
   if (!values.length) return fallback;
   const serialized = JSON.stringify(values[0].value);
@@ -9885,13 +10001,49 @@ function atZoom(value, level) {
     stops.push({ level: value[index], value: value[index + 1] });
   }
   const exact = stops.find((stop) => stop.level === level);
-  if (exact) return exact.value;
+  if (exact) return foldConstants(exact.value);
   const lower = [...stops].reverse().find((stop) => stop.level < level);
   const upper = stops.find((stop) => stop.level > level);
-  if (value[0] === "step") return lower?.value ?? value[2];
-  if (!lower) return upper?.value ?? 0;
-  if (!upper) return lower.value;
-  return ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
+  if (value[0] === "step") return foldConstants(lower?.value ?? value[2]);
+  if (!lower) return foldConstants(upper?.value ?? 0);
+  if (!upper) return foldConstants(lower.value);
+  const at = interpolationFactor2(
+    value[1],
+    level - lower.level,
+    upper.level - lower.level
+  );
+  const folded = Number.isFinite(at) ? interpolated(foldConstants(lower.value), foldConstants(upper.value), at) : void 0;
+  return folded ?? ["interpolate", value[1], level, lower.level, lower.value, upper.level, upper.value];
+}
+function foldConstants(value) {
+  if (!Array.isArray(value) || value[0] === "literal") return value;
+  const folded = value.map(foldConstants);
+  const [operator, ...operands] = folded;
+  if (!operands.length || !operands.every((operand) => typeof operand === "number")) return folded;
+  const numbers = operands;
+  const result = operator === "*" ? numbers.reduce((product, number) => product * number, 1) : operator === "+" ? numbers.reduce((sum, number) => sum + number, 0) : operator === "-" ? numbers.length === 1 ? -numbers[0] : numbers[0] - numbers[1] : operator === "/" && numbers.length === 2 ? numbers[0] / numbers[1] : operator === "max" ? Math.max(...numbers) : operator === "min" ? Math.min(...numbers) : void 0;
+  return result !== void 0 && Number.isFinite(result) ? result : folded;
+}
+function interpolated(lower, upper, at) {
+  if (typeof lower === "number" && typeof upper === "number") return lower + (upper - lower) * at;
+  if (JSON.stringify(lower) === JSON.stringify(upper)) return lower;
+  if (!Array.isArray(lower) || !Array.isArray(upper) || lower.length !== upper.length || lower[0] !== "case" && lower[0] !== "match" || lower[0] !== upper[0])
+    return void 0;
+  const first = lower[0] === "case" ? 1 : 2;
+  const result = lower.slice(0, first);
+  if (JSON.stringify(result) !== JSON.stringify(upper.slice(0, first))) return void 0;
+  for (let index = first; index < lower.length; index += 1) {
+    const output = (index - first) % 2 === 1 || index === lower.length - 1;
+    if (!output) {
+      if (JSON.stringify(lower[index]) !== JSON.stringify(upper[index])) return void 0;
+      result.push(lower[index]);
+      continue;
+    }
+    const value = interpolated(lower[index], upper[index], at);
+    if (value === void 0) return void 0;
+    result.push(value);
+  }
+  return result;
 }
 
 // src/modules/roads/compiler.ts
@@ -9962,6 +10114,10 @@ function compileRoads(request, context) {
       request?.classes?.[roadClass]
     );
     const treatments = resolveRoadTreatments(request, schema.fields, roadClass);
+    const drawn = {
+      field: schema.fields.class,
+      classes: new Set(tileflowRoadClassValues(roadClass))
+    };
     const roundaboutSurface = { roadClass };
     roundaboutSurfaces.push(roundaboutSurface);
     for (const structure of ["tunnel", "surface", "bridge"]) {
@@ -9984,7 +10140,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           phase,
-          phaseDefaults.color
+          phaseDefaults.color,
+          drawn
         );
         const contribution = {
           family: roadLinePhysicalFamily(roadClass, structure, phase),
@@ -10047,7 +10204,8 @@ function compileRoads(request, context) {
           treatments,
           structure,
           "fill",
-          roadColor(context, roadClass)
+          roadColor(context, roadClass),
+          drawn
         );
         const size = hatch.size === void 0 ? scaleStyleValue(treatedFill.width ?? 1, 0.68) : toMapLibreStyleValue(hatch.size);
         const minZoom = hatch.minZoom ?? treatedFill.minZoom;
@@ -10168,31 +10326,24 @@ function compileRoads(request, context) {
   const areaTargets = [
     {
       id: "tileflow-road-area",
-      filter: ["==", ["geometry-type"], "Polygon"],
+      kind: void 0,
       name: "road",
       style: areaStyles.road
     },
     {
       id: "tileflow-road-pedestrian-area",
-      filter: [
-        "all",
-        ["==", ["geometry-type"], "Polygon"],
-        tileflowRoadClassFilter(schema.fields, "pedestrian")
-      ],
+      kind: tileflowRoadClassFilter(schema.fields, "pedestrian"),
       name: "pedestrian",
       style: areaStyles.pedestrian
     },
     {
       id: "tileflow-road-pier-area",
-      filter: [
-        "all",
-        ["==", ["geometry-type"], "Polygon"],
-        ["==", ["get", schema.fields.class], "pier"]
-      ],
+      kind: ["==", ["get", schema.fields.class], "pier"],
       name: "pier",
       style: areaStyles.pier
     }
   ];
+  const polygons2 = ["==", ["geometry-type"], "Polygon"];
   let areaOrder = 900;
   for (const target of areaTargets) {
     if (!target.style) continue;
@@ -10202,13 +10353,19 @@ function compileRoads(request, context) {
         type: "fill",
         source,
         "source-layer": schema.layers.road,
-        filter: target.filter
+        filter: target.kind ? ["all", polygons2, target.kind] : polygons2
       },
       target.style
     )) {
+      const { filter: _polygonFilter, ...unfiltered } = area.layer;
+      const outline = area.phase === "outline" && schema.layers.transportationOutline ? {
+        ...unfiltered,
+        "source-layer": schema.layers.transportationOutline,
+        ...target.kind ? { filter: target.kind } : {}
+      } : area.layer;
       contributions.push({
         kind: "layer",
-        layer: area.layer,
+        layer: outline,
         localOrder: areaOrder++,
         owner: "roads",
         slot: "transport-areas",
@@ -10485,9 +10642,10 @@ function resolveRoadTreatments(request, fields2, roadClass) {
   add2(request?.modifiers?.unpaved, ["==", ["get", fields2.surface], "unpaved"]);
   add2(request?.modifiers?.indoor, flagFilter(fields2.indoor));
   add2(request?.modifiers?.official, flagFilter(fields2.official));
-  for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
-    add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
-  }
+  if (isTileflowPathRoadClass(roadClass) || roadClass === "track")
+    for (const [scale, style] of Object.entries(request?.mountainBike ?? {})) {
+      add2(style, ["==", ["to-string", ["get", fields2.mtbScale]], scale]);
+    }
   if (roadClass === "service") {
     for (const [serviceType, value] of Object.entries(serviceTypeValues)) {
       add2(request?.serviceTypes?.[serviceType], [
@@ -10499,7 +10657,7 @@ function resolveRoadTreatments(request, fields2, roadClass) {
   }
   return entries;
 }
-function applyRoadTreatments(base, treatments, structure, phase, fallbackColor) {
+function applyRoadTreatments(base, treatments, structure, phase, fallbackColor, drawn) {
   const result = { ...base };
   const paintProperties = [
     "blur",
@@ -10516,12 +10674,12 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
       return value === void 0 ? [] : [
         {
           condition,
-          resolve: () => expressionOutput(toMapLibreStyleValue(value))
+          resolve: () => expressionOutput(withinClasses(toMapLibreStyleValue(value), drawn))
         }
       ];
     });
     if (branches.length > 0) {
-      if (property === "dash" && isSolidRoadDash(result[property] ?? treatmentPaintDefaults.dash) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
+      if (property === "dash" && isSolidRoadDash(withinClasses(result[property] ?? treatmentPaintDefaults.dash, drawn)) && branches.every(({ resolve }) => isSolidRoadDash(resolve()))) {
         delete result[property];
         continue;
       }
@@ -10551,6 +10709,49 @@ function applyRoadTreatments(base, treatments, structure, phase, fallbackColor)
   }
   return result;
 }
+function withinClasses(value, drawn) {
+  const decided = (condition) => {
+    if (!Array.isArray(condition)) return typeof condition === "boolean" ? condition : void 0;
+    const [operator, ...operands] = condition;
+    const isClass = (operand) => Array.isArray(operand) && operand.length === 2 && operand[0] === "get" && (operand[1] === drawn.field || typeof operand[1] === "object" && operand[1] !== null && operand[1].kind === "tileflow-data-field" && operand[1].name === "class");
+    const among = (labels2) => {
+      const hits = [...drawn.classes].filter((value2) => labels2.includes(value2)).length;
+      return hits === 0 ? false : hits === drawn.classes.size ? true : void 0;
+    };
+    if ((operator === "==" || operator === "!=") && operands.length === 2) {
+      const label = isClass(operands[0]) ? operands[1] : isClass(operands[1]) ? operands[0] : null;
+      if (typeof label !== "string") return void 0;
+      const equal = among([label]);
+      return equal === void 0 ? void 0 : operator === "==" ? equal : !equal;
+    }
+    if (operator === "match" && operands.length === 4 && isClass(operands[0]) && typeof operands[2] === "boolean" && typeof operands[3] === "boolean") {
+      const labels2 = Array.isArray(operands[1]) ? operands[1] : [operands[1]];
+      const matched = among(labels2);
+      return matched === void 0 ? void 0 : matched ? operands[2] : operands[3];
+    }
+    if (operator === "!" && operands.length === 1) {
+      const inner = decided(operands[0]);
+      return inner === void 0 ? void 0 : !inner;
+    }
+    if (operator === "all" || operator === "any") {
+      const results = operands.map(decided);
+      if (results.includes(operator === "all" ? false : true)) return operator !== "all";
+      return results.every((result) => result !== void 0) ? operator === "all" : void 0;
+    }
+    return void 0;
+  };
+  if (!Array.isArray(value) || value[0] !== "case") return value;
+  const branches = [];
+  for (let index = 1; index < value.length - 1; index += 2) {
+    const holds = decided(value[index]);
+    if (holds === false) continue;
+    const output = withinClasses(value[index + 1], drawn);
+    if (holds === true) return branches.length ? ["case", ...branches, output] : output;
+    branches.push(value[index], output);
+  }
+  const fallback = withinClasses(value.at(-1), drawn);
+  return branches.length ? ["case", ...branches, fallback] : fallback;
+}
 function isSolidRoadDash(value) {
   const output = expressionOutput(value);
   const dash = Array.isArray(output) && output[0] === "literal" ? output[1] : output;
@@ -14286,7 +14487,7 @@ function compileRenderSelector(selector, data) {
   assertRenderSelectorConstraints(selector);
   return lowerSelector(selector, data);
 }
-function applyCompiledRenderStacks(input, operations2) {
+function applyCompiledRenderStacks(input, operations2, targetsOfOtherModes = /* @__PURE__ */ new Map()) {
   let layers2 = input.map(cloneJson21);
   const passes = operations2.filter(
     (operation) => operation.kind === "layer"
@@ -14317,9 +14518,10 @@ function applyCompiledRenderStacks(input, operations2) {
   for (const refinement of activeRefinements) {
     const index = findTargetIndex(layers2, refinement.target);
     if (index < 0 && !passTargets.has(refinement.target)) {
+      const other = targetsOfOtherModes.get(refinement.target);
       throw renderStackError(
         "unknown-refinement-target",
-        `Render refinement targets unknown semantic contribution: ${refinement.target}.`
+        other === void 0 ? `Render refinement targets unknown semantic contribution: ${refinement.target}.` : `Render refinement targets ${refinement.target}, ${describeOtherMode(other)}`
       );
     }
     if (refinement.placement !== void 0 && placementAnchor(refinement.placement) === refinement.target) {
@@ -14341,9 +14543,10 @@ function applyCompiledRenderStacks(input, operations2) {
   for (const operation of pending) {
     const anchor = placementAnchor(operation.placement);
     if (anchor !== void 0 && !knownTargets.has(anchor)) {
+      const other = targetsOfOtherModes.get(anchor);
       throw renderStackError(
         "unknown-or-circular-anchor",
-        `${operation.target} is placed beside unknown semantic target ${anchor}.`
+        other === void 0 ? `${operation.target} is placed beside unknown semantic target ${anchor}.` : `${operation.target} is placed beside ${anchor}, ${describeOtherMode(other)}`
       );
     }
   }
@@ -15016,6 +15219,9 @@ function assertOnlyKeys(input, allowed, description) {
     );
   }
 }
+function describeOtherMode({ activeMode, mode, owner }) {
+  return `which ${owner} draws only in mode '${mode}'; this map draws ${owner} in mode '${activeMode}'. Place the operation beside a target drawn in mode '${activeMode}' or at a band edge, or remove it; refine({mode: '${activeMode}', renderStack: reset()}) removes an inherited ${owner} render stack.`;
+}
 function renderStackError(code, message) {
   return Object.assign(new Error(message), { code, name: "TileflowRenderStackError" });
 }
@@ -16106,6 +16312,7 @@ function boundedThemeNumberSchema(min, max) {
     }).strict()
   ]);
 }
+var entranceBandSchema = z7.tuple([z7.number().finite().min(0).max(24), z7.number().finite().min(0).max(24)]).refine(([from, to]) => from < to, "A band starts at a lower zoom than it ends.");
 var modelRoleLightingSchema = z7.object({
   emissiveStrength: boundedThemeNumberSchema(0, 5).optional(),
   emissiveVariation: boundedThemeNumberSchema(0, 1).optional(),
@@ -16161,6 +16368,7 @@ var buildingsModuleSchema = z7.object({
       lamp: modelRoleLightingSchema.optional(),
       logo: modelRoleLightingSchema.optional()
     }).strict().optional(),
+    entrance: z7.object({ buildings: entranceBandSchema.optional(), models: entranceBandSchema.optional() }).strict().optional(),
     occlusion: z7.boolean().optional(),
     modelOcclusion: boundedThemeNumberSchema(0, 1).optional(),
     shadows: z7.boolean().optional(),
@@ -16540,6 +16748,7 @@ var layerBindingsSchema = z7.object({
   streetFurniture: z7.string().trim().min(1).optional(),
   trafficControl: z7.string().trim().min(1).optional(),
   tree: z7.string().trim().min(1).optional(),
+  transportationOutline: z7.string().trim().min(1).optional(),
   water: z7.string().trim().min(1),
   waterName: z7.string().trim().min(1),
   waterway: z7.string().trim().min(1)
@@ -18415,6 +18624,8 @@ function mergeRoadLineGroup(key, layers2) {
   const paintKeys = new Set(layers2.flatMap((layer) => Object.keys(layer.style.appearance ?? {})));
   for (const key2 of paintKeys) {
     const values = layers2.map((layer) => layer.style.appearance?.[key2]);
+    if (key2 === "line-dasharray" && values.every((value) => isSolidDash(value ?? linePaintDefaults[key2])))
+      continue;
     const combined = combineConditionalValues(
       values.map((value, index) => ({
         condition: conditions[index],
@@ -19208,6 +19419,7 @@ function tileflowBuildings3DDesignOf(module, context, layers2, buildingModels, t
       )
     } : {},
     windows: style.windows === true,
+    ...readTileflowBuildingsEntrance(style.entrance),
     shadows: typeof style.shadows === "boolean" ? style.shadows : defaults4.shadows,
     occlusion: typeof style.occlusion === "boolean" ? style.occlusion : defaults4.occlusion,
     modelOcclusion: number(style.modelOcclusion, defaults4.modelOcclusion),
@@ -19491,7 +19703,11 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   const requestedRenderOperations = domainIR.renderOperations;
   const stackedFamilies = runCompilationPhase(
     "render-stack",
-    () => applyCompiledRenderStacks(assembledFamilies, requestedRenderOperations)
+    () => applyCompiledRenderStacks(
+      assembledFamilies,
+      requestedRenderOperations,
+      buildingTargetsOfOtherModes(modules.buildings)
+    )
   );
   const plannedFamilies = runCompilationPhase(
     "physical-planner",
@@ -20296,6 +20512,9 @@ function applyModuleOperation(resolved, moduleName, operation, mapId, path) {
         assertNoReset(patch, mapId, `${path}/patches/${index}`, true);
         next = applyModulePatch(next, patch, mapId, `${path}/patches/${index}`);
       }
+      if (isPlainRecord4(next.renderStack) && Object.keys(next.renderStack).length === 0) {
+        delete next.renderStack;
+      }
       assertModuleOwner(next, moduleName, mapId, path);
       resolved[moduleName] = next;
       return;