@nika-js/onlymap 0.4.6 → 0.5.0

package/dist/{index-DjlGZov2.js → index-DuY3Zn6r.js}

@@ -1,4 +1,4 @@
-import { ai as Bt, ak as Xt, al as Yt, am as Us } from "./index-DSkgI4Oc.js";
+import { ai as Bt, av as Xt, aw as Yt, ax as Us } from "./index-DiYFebYs.js";
 import { w as gs, t as Hs, f as Ws, m as Qs } from "./mgrs-BY9bIvp4.js";
 import { c as Xs } from "./convert-arrow-schema-DrAihRf9.js";
 import { y as Ys, A as bt, a as Ks, z as Vs, R as Zs } from "./recordbatch-Bpc0uxFn.js";

package/dist/layer-registry.d.ts

@@ -10,6 +10,20 @@ export interface PropDescriptor {
     type?: "string" | "number" | "boolean" | "json" | "color";
     required?: boolean;
     default?: unknown;
+    /**
+     * Only for kind: "accessor" — a `$field`-style expression compiled and
+     * used AS the accessor when the author writes no `attr` at all (a true
+     * zero-attribute default, not a fallback VALUE the way scalar `default`
+     * is). Compiled through the exact same accessorCache path an authored
+     * attribute would take, so it gets real updateTriggers/caching and — for
+     * a `*Color`-named deckProp — the same hex-string-to-RGB conversion. An
+     * authored `attr` always wins; this only fills the gap when absent. Keep
+     * the field name itself data-agnostic/reserved (e.g. `$fill_color`), not
+     * tied to one data format, so the layer schema stays format-agnostic —
+     * whichever DataFormat populates that field gets the free default, not
+     * just the one that motivated adding it (CityJSON surfaces mode).
+     */
+    defaultExpr?: string;
     /** Only for kind: "shorthand" — the deckProp it expands to when no accessor overrides it. */
     shorthandFor?: string;
 }

package/dist/{lerc-CaQOmDCP.js → lerc-BhtFlCQ3.js}

@@ -1,4 +1,4 @@
-import { C as a, D as s } from "./raster-DMq8FgiV.js";
+import { C as a, D as s } from "./raster-BpVAEzbU.js";
 const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
 }, Symbol.toStringTag, { value: "Module" }));
@@ -8,7 +8,7 @@ var t;
 })(t || (t = {}));
 let l = !1;
 async function d() {
-  const e = await import("./LercDecode.es-B49qauXg.js");
+  const e = await import("./LercDecode.es-B-OFS9hR.js");
   return l || (await e.load(), l = !0), e;
 }
 async function i(e, r) {

package/dist/license.d.ts

@@ -50,15 +50,41 @@ export declare function domainMatches(hostname: string, domains: string[]): bool
  * warning — a bad key must never break the map.
  */
 export declare function configureLicense(key: string): Promise<void>;
+/** One layer whose data the row cap cut down this pass — drives the viewer-facing notice. */
+export interface TruncatedLayer {
+    id: string;
+    /** Rows that DID render (the cap). */
+    shown: number;
+    /** Rows the layer actually had. */
+    total: number;
+}
+export interface LicenseGateResult {
+    irs: LayerIR[];
+    /** Empty (a shared frozen constant) on the overwhelmingly common no-violation pass. */
+    truncated: readonly TruncatedLayer[];
+}
 /**
- * DECIDED violation mode: per-layer hard drop, deterministic — layers past
- * the count cap (manifest order) don't render; an over-cap layer renders
- * NOTHING (never a truncated subset — truncation looks like a data bug and
- * hides the gate). Runtime-internal layers (trace temps, draw preview,
- * tooltip plumbing) neither count nor drop. Violations report once per
- * (layer, reason) through `report` until the violation clears (`warned` is
- * the caller-owned dedup set).
+ * DECIDED violation mode (revised 2026-07-28): layers past the COUNT cap
+ * (manifest order) still hard-drop — a sixth layer has no meaningful partial
+ * form. An over-ROW-cap layer now renders its first `maxRowsPerLayer` rows
+ * instead of nothing, because the previous hard drop turned one row over the
+ * line into a blank layer, and the cliff landed unpredictably: CityJSON's
+ * `?om-surfaces=1` emits ~33 rows per building with a long tail (one building
+ * in the sample tile is 963 faces), so "how many buildings fit" is not
+ * something an author can reason about in advance.
+ *
+ * The original objection to truncation — that it looks like a data bug and
+ * hides the gate — is answered by making it VISIBLE rather than by rendering
+ * nothing: `truncated` drives a dismissible viewer-facing notice (see
+ * quota-notice.ts), while this `report` stream keeps severity "error" for the
+ * dev/agent channel. The subset is arbitrary (source order, which for most
+ * formats is not spatially meaningful) and the message says so, since a
+ * scattered subset otherwise reads as a rendering fault.
+ *
+ * Runtime-internal layers (trace temps, draw preview, tooltip plumbing)
+ * neither count nor drop. Violations report once per (layer, reason) through
+ * `report` until the violation clears (`warned` is the caller-owned dedup set).
  */
-export declare function applyLicenseGates(irs: LayerIR[], report: (entry: ValidationEntry) => void, warned: Set<string>): LayerIR[];
+export declare function applyLicenseGates(irs: LayerIR[], report: (entry: ValidationEntry) => void, warned: Set<string>): LicenseGateResult;
 export declare function setLicensePublicKeyForTests(rawKey: Uint8Array | null): void;
 export declare function resetLicenseForTests(): void;