@ggts-sh/spec 0.43.0

package/dist/portability-check.js

@@ -0,0 +1,121 @@
+/** @internal Shared by strict walk and lossy clone. */
+export function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function issueFor(value) {
+    switch (typeof value) {
+        case "string":
+        case "boolean":
+            return null;
+        case "number":
+            return Number.isFinite(value)
+                ? null
+                : "non-finite number (portable specs encode NaN/Infinity as null)";
+        case "undefined":
+            return "undefined (omit the property instead)";
+        case "function":
+            return "function (use toPortableLossy() to strip { fn } accessors, or keep a RuntimeSpec)";
+        case "symbol":
+            return "symbol";
+        case "bigint":
+            return "bigint (convert to number or string)";
+        default:
+            return null; // objects handled by the walker
+    }
+}
+/**
+ * Walk a value tree, collecting portability issues.
+ * When `stopAfter` is set, stop once that many issues are recorded (used by
+ * `isPortable` for an early-exit existence check).
+ */
+function walk(value, path, seen, issues, stopAfter) {
+    if (stopAfter !== undefined && issues.length >= stopAfter)
+        return;
+    const primitiveIssue = issueFor(value);
+    if (primitiveIssue !== null) {
+        issues.push({ path, reason: primitiveIssue });
+        return;
+    }
+    if (typeof value !== "object" || value === null)
+        return;
+    if (seen.has(value)) {
+        issues.push({ path, reason: "circular reference" });
+        return;
+    }
+    if (value instanceof Date) {
+        issues.push({
+            path,
+            reason: "Date (portable specs carry dates as ISO 8601 strings)",
+        });
+        return;
+    }
+    if (Array.isArray(value)) {
+        seen.add(value);
+        for (let i = 0; i < value.length; i++) {
+            walk(value[i], `${path}/${i}`, seen, issues, stopAfter);
+            if (stopAfter !== undefined && issues.length >= stopAfter)
+                break;
+        }
+        seen.delete(value);
+        return;
+    }
+    if (!isPlainObject(value)) {
+        issues.push({
+            path,
+            reason: `non-plain object (${Object.prototype.toString.call(value)})`,
+        });
+        return;
+    }
+    seen.add(value);
+    // Prefer for…in over Object.entries: entries eagerly Gets every property
+    // value (including later getters), defeating stopAfter. Engines still list
+    // own keys up front (OwnPropertyKeys); the short-circuit here is on value
+    // Gets and recursive walks — not on key listing. for…in also skips keys
+    // deleted by an earlier getter before we reach them.
+    for (const key in value) {
+        if (!Object.hasOwn(value, key))
+            continue;
+        walk(value[key], `${path}/${key}`, seen, issues, stopAfter);
+        if (stopAfter !== undefined && issues.length >= stopAfter)
+            break;
+    }
+    seen.delete(value);
+}
+/** Every reason `value` fails to be strictly-JSON, with paths. Empty = portable. */
+export function portabilityIssues(value) {
+    const issues = [];
+    walk(value, "", new Set(), issues);
+    return issues;
+}
+/** True when `spec` contains only strictly-JSON values (narrowing type guard). */
+export function isPortable(spec) {
+    const issues = [];
+    walk(spec, "", new Set(), issues, 1);
+    return issues.length === 0;
+}
+/** Thrown by toPortable(): lists EVERY unserializable path, not just the first. */
+export class UnportableSpecError extends Error {
+    issues;
+    constructor(issues) {
+        const lines = issues.map((i) => `  ${i.path || "/"}: ${i.reason}`);
+        super(`Spec is not portable (${issues.length} issue${issues.length === 1 ? "" : "s"}):\n` +
+            lines.join("\n"));
+        this.name = "UnportableSpecError";
+        this.issues = issues;
+    }
+}
+/**
+ * Convert a RuntimeSpec to a PortableSpec, REJECTING (UnportableSpecError,
+ * with every offending path) if anything unserializable is present.
+ * Returns a structurally-shared-nothing deep copy.
+ */
+export function toPortable(spec) {
+    const issues = portabilityIssues(spec);
+    if (issues.length > 0)
+        throw new UnportableSpecError(issues);
+    return JSON.parse(JSON.stringify(spec));
+}
+//# sourceMappingURL=portability-check.js.map

package/dist/portability-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portability-check.js","sourceRoot":"","sources":["../src/portability-check.ts"],"names":[],"mappings":"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"}

package/dist/portability-lossy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Explicit lossy RuntimeSpec → PortableSpec conversion for tooling.
+ * Strict checks: portability-check.ts. Public facade: portability.ts.
+ */
+import type { PortableSpec } from "./schema.js";
+import type { RuntimeSpec } from "./runtime.js";
+export interface LossyResult {
+    spec: PortableSpec;
+    /** Paths that were REMOVED because they cannot travel as JSON. */
+    dropped: string[];
+}
+/**
+ * Explicit lossy conversion for tooling: strips `{ fn }` accessors and any
+ * other unserializable values, returning the portable remainder plus the list
+ * of dropped paths. Dates are coerced to ISO strings, non-finite numbers to
+ * null (coercions are not reported as drops).
+ */
+export declare function toPortableLossy(spec: RuntimeSpec): LossyResult;
+//# sourceMappingURL=portability-lossy.d.ts.map

package/dist/portability-lossy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portability-lossy.d.ts","sourceRoot":"","sources":["../src/portability-lossy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,YAAY,CAAC;IACnB,kEAAkE;IAClE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AA0DD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAI9D"}

package/dist/portability-lossy.js

@@ -0,0 +1,65 @@
+import { isPlainObject } from "./portability-check.js";
+function lossyClone(value, path, seen, dropped) {
+    switch (typeof value) {
+        case "string":
+        case "boolean":
+            return { keep: true, value };
+        case "number":
+            return { keep: true, value: Number.isFinite(value) ? value : null };
+        case "function":
+        case "symbol":
+        case "undefined":
+        case "bigint":
+            dropped.push(path);
+            return { keep: false };
+        default:
+            break;
+    }
+    if (value === null)
+        return { keep: true, value: null };
+    const obj = value;
+    if (seen.has(obj)) {
+        dropped.push(path);
+        return { keep: false };
+    }
+    if (obj instanceof Date) {
+        // Coercion, not a drop: dates travel as ISO strings per the plan.
+        return { keep: true, value: Number.isNaN(obj.getTime()) ? null : obj.toISOString() };
+    }
+    if (Array.isArray(obj)) {
+        seen.add(obj);
+        const out = [];
+        for (let i = 0; i < obj.length; i++) {
+            const r = lossyClone(obj[i], `${path}/${i}`, seen, dropped);
+            // Dropped array elements become null so indices stay row-aligned.
+            out.push(r.keep ? r.value : null);
+        }
+        seen.delete(obj);
+        return { keep: true, value: out };
+    }
+    if (!isPlainObject(obj)) {
+        dropped.push(path);
+        return { keep: false };
+    }
+    seen.add(obj);
+    const out = {};
+    for (const [key, v] of Object.entries(obj)) {
+        const r = lossyClone(v, `${path}/${key}`, seen, dropped);
+        if (r.keep)
+            out[key] = r.value;
+    }
+    seen.delete(obj);
+    return { keep: true, value: out };
+}
+/**
+ * Explicit lossy conversion for tooling: strips `{ fn }` accessors and any
+ * other unserializable values, returning the portable remainder plus the list
+ * of dropped paths. Dates are coerced to ISO strings, non-finite numbers to
+ * null (coercions are not reported as drops).
+ */
+export function toPortableLossy(spec) {
+    const dropped = [];
+    const r = lossyClone(spec, "", new Set(), dropped);
+    return { spec: (r.keep ? r.value : {}), dropped };
+}
+//# sourceMappingURL=portability-lossy.js.map

package/dist/portability-lossy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portability-lossy.js","sourceRoot":"","sources":["../src/portability-lossy.ts"],"names":[],"mappings":"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"}

package/dist/portability.d.ts

@@ -0,0 +1,23 @@
+/**
+ * PortableSpec vs RuntimeSpec (plan: "Two spec types, explicitly split").
+ *
+ * PortableSpec is strictly JSON, defined over a recursive JSONValue: no Date,
+ * undefined, functions, bigint, symbols, typed arrays, cycles, non-finite
+ * numbers. Dates travel as ISO strings; non-finite numbers as null.
+ *
+ * RuntimeSpec is the in-memory superset: `{ fn }` channel accessors are legal.
+ * - `isPortable()` narrows.
+ * - `toPortable()` REJECTS with a structured error listing every
+ *   unserializable path (one behavior, never "strip or reject").
+ * - `toPortableLossy()` is the separate, explicit tool for tooling: it strips
+ *   what cannot travel and returns `{ spec, dropped }` (dates are COERCED to
+ *   ISO strings and non-finite numbers to null — coercions are not "dropped").
+ *
+ * Implementation:
+ *  - portability-check.ts — strict walk, isPortable, toPortable
+ *  - portability-lossy.ts — toPortableLossy
+ * This file re-exports the public surface so package imports stay on ./portability.js.
+ */
+export { isPortable, portabilityIssues, toPortable, UnportableSpecError, type JSONValue, type PortabilityIssue, } from "./portability-check.js";
+export { toPortableLossy, type LossyResult } from "./portability-lossy.js";
+//# sourceMappingURL=portability.d.ts.map

package/dist/portability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portability.d.ts","sourceRoot":"","sources":["../src/portability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/portability.js

@@ -0,0 +1,23 @@
+/**
+ * PortableSpec vs RuntimeSpec (plan: "Two spec types, explicitly split").
+ *
+ * PortableSpec is strictly JSON, defined over a recursive JSONValue: no Date,
+ * undefined, functions, bigint, symbols, typed arrays, cycles, non-finite
+ * numbers. Dates travel as ISO strings; non-finite numbers as null.
+ *
+ * RuntimeSpec is the in-memory superset: `{ fn }` channel accessors are legal.
+ * - `isPortable()` narrows.
+ * - `toPortable()` REJECTS with a structured error listing every
+ *   unserializable path (one behavior, never "strip or reject").
+ * - `toPortableLossy()` is the separate, explicit tool for tooling: it strips
+ *   what cannot travel and returns `{ spec, dropped }` (dates are COERCED to
+ *   ISO strings and non-finite numbers to null — coercions are not "dropped").
+ *
+ * Implementation:
+ *  - portability-check.ts — strict walk, isPortable, toPortable
+ *  - portability-lossy.ts — toPortableLossy
+ * This file re-exports the public surface so package imports stay on ./portability.js.
+ */
+export { isPortable, portabilityIssues, toPortable, UnportableSpecError, } from "./portability-check.js";
+export { toPortableLossy } from "./portability-lossy.js";
+//# sourceMappingURL=portability.js.map

package/dist/portability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portability.js","sourceRoot":"","sources":["../src/portability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,mBAAmB,GAGpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,eAAe,EAAoB,MAAM,wBAAwB,CAAC"}

package/dist/portable-builder.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Lean portable builder implementation (values for `@ggts-sh/spec/portable`).
+ * Index surface re-exports live in {@link ./portable-entry.ts}.
+ */
+import type { AesInput } from "./normalize.js";
+import { type DataInput } from "./builder-data.js";
+import { GGBuilderCore } from "./builder-core.js";
+import type { PortableSpec } from "./schema.js";
+/** Identity helper for aesthetic mappings (same as full package `aes`). */
+export declare function aes(mapping: AesInput): AesInput;
+declare const GGBuilder_base: {
+    new (...args: any[]): {
+        scaleAlphaBinned(options?: import("./scale-style-helpers.js").SequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleAlphaContinuous(options?: import("./scale-style-helpers.js").SequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleAlphaDate(options?: import("./scale-style-helpers.js").TemporalNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleAlphaDatetime(options?: import("./scale-style-helpers.js").TemporalNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleAlphaDiscrete(options?: import("./scale-style-helpers.js").DiscreteNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleAlphaIdentity(options?: import("./scale-style-helpers.js").IdentityNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleAlphaManual(options: import("./scale-style-helpers.js").ManualNumericStyleScaleOptions): import("./builder.js").GGBuilder;
+        scaleAlphaOrdinal(options?: import("./scale-style-helpers.js").DiscreteNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorBinned(options?: import("./scale-color-helpers.js").SequentialColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorBrewer(options?: import("./scale-color-helpers.js").ColorBrewerScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorContinuous(options?: import("./scale-color-helpers.js").SequentialColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorDate(options?: import("./scale-color-helpers.js").TemporalColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorDatetime(options?: import("./scale-color-helpers.js").TemporalColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorDiscrete(options?: import("./scale-color-helpers.js").DiscreteColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorDistiller(options?: import("./scale-color-helpers.js").ColorDistillerScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorFermenter(options?: import("./scale-color-helpers.js").ColorFermenterScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorGradient(options?: import("./scale-color-stops.js").GradientScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorGradient2(options?: import("./scale-color-stops.js").Gradient2ScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorGradientn(options?: import("./scale-color-stops.js").GradientnScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorGrey(options?: import("./scale-color-hue-grey.js").GreyScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorHue(options?: import("./scale-color-hue-grey.js").HueScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorIdentity(options?: import("./scale-color-helpers.js").IdentityColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorLog10(options?: import("./scale-color-helpers.js").TransformedColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorManual(options: import("./scale-color-helpers.js").ManualColorScaleOptions): import("./builder.js").GGBuilder;
+        scaleColorOrdinal(options?: import("./scale-color-helpers.js").DiscreteColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorSqrt(options?: import("./scale-color-helpers.js").TransformedColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorSteps(options?: import("./scale-color-stops.js").StepsScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorSteps2(options?: import("./scale-color-stops.js").Steps2ScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorStepsn(options?: import("./scale-color-stops.js").StepsnScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorViridisB(options?: import("./scale-color-viridis.js").ViridisScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorViridisC(options?: import("./scale-color-viridis.js").ViridisScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleColorViridisD(options?: import("./scale-color-viridis.js").ViridisScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillBinned(options?: import("./scale-color-helpers.js").SequentialColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillBrewer(options?: import("./scale-color-helpers.js").ColorBrewerScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillContinuous(options?: import("./scale-color-helpers.js").SequentialColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillDate(options?: import("./scale-color-helpers.js").TemporalColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillDatetime(options?: import("./scale-color-helpers.js").TemporalColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillDiscrete(options?: import("./scale-color-helpers.js").DiscreteColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillDistiller(options?: import("./scale-color-helpers.js").ColorDistillerScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillFermenter(options?: import("./scale-color-helpers.js").ColorFermenterScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillGradient(options?: import("./scale-color-stops.js").GradientScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillGradient2(options?: import("./scale-color-stops.js").Gradient2ScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillGradientn(options?: import("./scale-color-stops.js").GradientnScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillGrey(options?: import("./scale-color-hue-grey.js").GreyScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillHue(options?: import("./scale-color-hue-grey.js").HueScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillIdentity(options?: import("./scale-color-helpers.js").IdentityColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillLog10(options?: import("./scale-color-helpers.js").TransformedColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillManual(options: import("./scale-color-helpers.js").ManualColorScaleOptions): import("./builder.js").GGBuilder;
+        scaleFillOrdinal(options?: import("./scale-color-helpers.js").DiscreteColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillSqrt(options?: import("./scale-color-helpers.js").TransformedColorScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillSteps(options?: import("./scale-color-stops.js").StepsScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillSteps2(options?: import("./scale-color-stops.js").Steps2ScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillStepsn(options?: import("./scale-color-stops.js").StepsnScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillViridisB(options?: import("./scale-color-viridis.js").ViridisScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillViridisC(options?: import("./scale-color-viridis.js").ViridisScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleFillViridisD(options?: import("./scale-color-viridis.js").ViridisScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinetypeBinned(options?: (Omit<import("./scale-style-helpers.js").FiniteStyleScaleOptions<"solid" | "dashed" | "dotted" | "dotdash" | "longdash" | "twodash">, "domain" | "domainMode" | "onExhaust"> & {
+            domain?: readonly [number, number];
+        }) | undefined): import("./builder.js").GGBuilder;
+        scaleLinetypeDiscrete(options?: {
+            reverse?: boolean;
+            domain?: readonly import("./schema-types.js").CellValue[];
+            naValue?: "solid" | "dashed" | "dotted" | "dotdash" | "longdash" | "twodash";
+            guide?: import("./schema-types.js").GuideSpec;
+            domainMode?: "grow" | "data";
+            range?: readonly ("solid" | "dashed" | "dotted" | "dotdash" | "longdash" | "twodash")[];
+            unknownValue?: "solid" | "dashed" | "dotted" | "dotdash" | "longdash" | "twodash";
+            onExhaust?: "cycle" | "error";
+        } | undefined): import("./builder.js").GGBuilder;
+        scaleLinetypeIdentity(options?: import("./scale-style-helpers.js").IdentityFiniteStyleScaleOptions<"solid" | "dashed" | "dotted" | "dotdash" | "longdash" | "twodash"> | undefined): import("./builder.js").GGBuilder;
+        scaleLinetypeManual(options: import("./scale-style-helpers.js").ManualFiniteStyleScaleOptions<"solid" | "dashed" | "dotted" | "dotdash" | "longdash" | "twodash">): import("./builder.js").GGBuilder;
+        scaleLinewidthBinned(options?: import("./scale-style-helpers.js").SequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinewidthContinuous(options?: import("./scale-style-helpers.js").SequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinewidthDate(options?: import("./scale-style-helpers.js").TemporalNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinewidthDatetime(options?: import("./scale-style-helpers.js").TemporalNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinewidthDiscrete(options?: import("./scale-style-helpers.js").DiscreteNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinewidthIdentity(options?: import("./scale-style-helpers.js").IdentityNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleLinewidthManual(options: import("./scale-style-helpers.js").ManualNumericStyleScaleOptions): import("./builder.js").GGBuilder;
+        scaleLinewidthOrdinal(options?: import("./scale-style-helpers.js").DiscreteNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleRadius(options?: import("./scale-style-helpers.js").SizeSequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleShapeBinned(options?: (Omit<import("./scale-style-helpers.js").FiniteStyleScaleOptions<"circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open">, "domain" | "domainMode" | "onExhaust"> & {
+            domain?: readonly [number, number];
+        }) | undefined): import("./builder.js").GGBuilder;
+        scaleShapeDiscrete(options?: {
+            reverse?: boolean;
+            domain?: readonly import("./schema-types.js").CellValue[];
+            naValue?: "circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open";
+            guide?: import("./schema-types.js").GuideSpec;
+            domainMode?: "grow" | "data";
+            range?: readonly ("circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open")[];
+            unknownValue?: "circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open";
+            onExhaust?: "cycle" | "error";
+        } | undefined): import("./builder.js").GGBuilder;
+        scaleShapeIdentity(options?: import("./scale-style-helpers.js").IdentityFiniteStyleScaleOptions<"circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open"> | undefined): import("./builder.js").GGBuilder;
+        scaleShapeManual(options: import("./scale-style-helpers.js").ManualFiniteStyleScaleOptions<"circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open">): import("./builder.js").GGBuilder;
+        scaleShapeOrdinal(options?: {
+            reverse?: boolean;
+            domain?: readonly import("./schema-types.js").CellValue[];
+            naValue?: "circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open";
+            guide?: import("./schema-types.js").GuideSpec;
+            domainMode?: "grow" | "data";
+            range?: readonly ("circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open")[];
+            unknownValue?: "circle" | "triangle" | "square" | "diamond" | "plus" | "cross" | "circle-open";
+            onExhaust?: "cycle" | "error";
+        } | undefined): import("./builder.js").GGBuilder;
+        scaleSizeArea(options?: import("./scale-style-helpers.js").SizeAreaScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeBinned(options?: import("./scale-style-helpers.js").SizeSequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeBinnedArea(options?: import("./scale-style-helpers.js").SizeAreaScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeContinuous(options?: import("./scale-style-helpers.js").SizeSequentialStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeDate(options?: import("./scale-style-helpers.js").SizeTemporalNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeDatetime(options?: import("./scale-style-helpers.js").SizeTemporalNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeDiscrete(options?: import("./scale-style-helpers.js").DiscreteNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeIdentity(options?: import("./scale-style-helpers.js").IdentityNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleSizeManual(options: import("./scale-style-helpers.js").ManualNumericStyleScaleOptions): import("./builder.js").GGBuilder;
+        scaleSizeOrdinal(options?: import("./scale-style-helpers.js").DiscreteNumericStyleScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXBinned(options?: import("./scale-position-helpers.js").ContinuousPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXContinuous(options?: import("./scale-position-helpers.js").ContinuousPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXDate(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXDatetime(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXDiscrete(options?: import("./scale-position-helpers.js").DiscretePositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXLog10(options?: import("./scale-position-helpers.js").TransformedPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXMonthDay(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXReverse(options?: Omit<import("./scale-position-helpers.js").ContinuousPositionScaleOptions, "transform" | "reverse"> | undefined): import("./builder.js").GGBuilder;
+        scaleXSqrt(options?: import("./scale-position-helpers.js").TransformedPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleXTime(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYBinned(options?: import("./scale-position-helpers.js").ContinuousPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYContinuous(options?: import("./scale-position-helpers.js").ContinuousPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYDate(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYDatetime(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYDiscrete(options?: import("./scale-position-helpers.js").DiscretePositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYLog10(options?: import("./scale-position-helpers.js").TransformedPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYMonthDay(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYReverse(options?: Omit<import("./scale-position-helpers.js").ContinuousPositionScaleOptions, "transform" | "reverse"> | undefined): import("./builder.js").GGBuilder;
+        scaleYSqrt(options?: import("./scale-position-helpers.js").TransformedPositionScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scaleYTime(options?: import("./scale-position-helpers.js").TemporalScaleOptions | undefined): import("./builder.js").GGBuilder;
+        scales(scales: import("./schema-types.js").Scales): import("./builder.js").GGBuilder;
+    };
+} & {
+    new (...args: any[]): {
+        geomPoint(options?: import("./builder-options.js").GeomPointOptions): import("./builder.js").GGBuilder;
+        geomLine(options?: import("./builder-options.js").GeomLineOptions): import("./builder.js").GGBuilder;
+        geomPath(options?: import("./builder-options.js").GeomPathOptions): import("./builder.js").GGBuilder;
+        geomCol(options?: import("./builder-options.js").GeomColOptions): import("./builder.js").GGBuilder;
+        geomBar(options?: import("./builder-options.js").GeomBarOptions): import("./builder.js").GGBuilder;
+        geomHistogram(options?: import("./builder-options.js").GeomHistogramOptions): import("./builder.js").GGBuilder;
+        geomFreqpoly(options?: import("./builder-options.js").GeomFreqpolyOptions): import("./builder.js").GGBuilder;
+        geomArea(options?: import("./builder-options.js").GeomAreaOptions): import("./builder.js").GGBuilder;
+        geomRule(options?: import("./builder-options.js").GeomRuleOptions): import("./builder.js").GGBuilder;
+        geomHline(options?: import("./builder-options.js").GeomHlineOptions): import("./builder.js").GGBuilder;
+        geomVline(options?: import("./builder-options.js").GeomVlineOptions): import("./builder.js").GGBuilder;
+        geomText(options?: import("./builder-options.js").GeomTextOptions): import("./builder.js").GGBuilder;
+        geomLabel(options?: import("./builder-options.js").GeomLabelOptions): import("./builder.js").GGBuilder;
+        geomSmooth(options?: import("./builder-options.js").GeomSmoothOptions): import("./builder.js").GGBuilder;
+        geomQuantile(options?: import("./builder-options.js").GeomQuantileOptions): import("./builder.js").GGBuilder;
+        geomBoxplot(options?: import("./builder-options.js").GeomBoxplotOptions): import("./builder.js").GGBuilder;
+        geomDensity(options?: import("./builder-options.js").GeomDensityOptions): import("./builder.js").GGBuilder;
+        geomErrorbar(options?: import("./builder-options.js").GeomErrorbarOptions): import("./builder.js").GGBuilder;
+        geomLinerange(options?: import("./builder-options.js").GeomLinerangeOptions): import("./builder.js").GGBuilder;
+        geomPointrange(options?: import("./builder-options.js").GeomPointrangeOptions): import("./builder.js").GGBuilder;
+        geomCrossbar(options?: import("./builder-options.js").GeomCrossbarOptions): import("./builder.js").GGBuilder;
+        geomRect(options?: import("./builder-options.js").GeomRectOptions): import("./builder.js").GGBuilder;
+        geomTile(options?: import("./builder-options.js").GeomTileOptions): import("./builder.js").GGBuilder;
+        geomRaster(options?: import("./builder-options.js").GeomRasterOptions): import("./builder.js").GGBuilder;
+        geomRibbon(options?: import("./builder-options.js").GeomRibbonOptions): import("./builder.js").GGBuilder;
+        geomSegment(options?: import("./builder-options.js").GeomSegmentOptions): import("./builder.js").GGBuilder;
+        geomCount(options?: import("./builder-options.js").GeomCountOptions): import("./builder.js").GGBuilder;
+        geomViolin(options?: import("./builder-options.js").GeomViolinOptions): import("./builder.js").GGBuilder;
+        geomFunction(options: import("./builder-options.js").GeomFunctionOptions): import("./builder.js").GGBuilder;
+        geomPolygon(options?: import("./builder-options.js").GeomPolygonOptions): import("./builder.js").GGBuilder;
+        geomHex(options?: import("./builder-options.js").GeomHexOptions): import("./builder.js").GGBuilder;
+        geomBin2d(options?: import("./builder-options.js").GeomBin2dOptions): import("./builder.js").GGBuilder;
+        geomAbline(options?: import("./builder-options.js").GeomAblineOptions): import("./builder.js").GGBuilder;
+        geomCurve(options?: import("./builder-options.js").GeomCurveOptions): import("./builder.js").GGBuilder;
+        geomContour(options?: import("./builder-options.js").GeomContourOptions): import("./builder.js").GGBuilder;
+        geomDensity2d(options?: import("./builder-options.js").GeomDensity2dOptions): import("./builder.js").GGBuilder;
+        geomDensity2dFilled(options?: import("./builder-options.js").GeomDensity2dFilledOptions): import("./builder.js").GGBuilder;
+        geomDotplot(options?: import("./builder-options.js").GeomDotplotOptions): import("./builder.js").GGBuilder;
+        geomMap(options: import("./builder-options.js").GeomMapOptions): import("./builder.js").GGBuilder;
+        geomSf(options?: import("./builder-options.js").GeomSfOptions): import("./builder.js").GGBuilder;
+        geomSfText(options?: import("./builder-options.js").GeomSfTextOptions): import("./builder.js").GGBuilder;
+        geomSfLabel(options?: import("./builder-options.js").GeomSfLabelOptions): import("./builder.js").GGBuilder;
+        geomBlank(options?: import("./builder-options.js").GeomBlankOptions): import("./builder.js").GGBuilder;
+        geomJitter(options?: import("./builder-options.js").GeomJitterOptions): import("./builder.js").GGBuilder;
+        geomSpoke(options?: import("./builder-options.js").GeomSpokeOptions): import("./builder.js").GGBuilder;
+        geomRug(options?: import("./builder-options.js").GeomRugOptions): import("./builder.js").GGBuilder;
+        geomStep(options?: import("./builder-options.js").GeomStepOptions): import("./builder.js").GGBuilder;
+        geomQq(options?: import("./builder-options.js").GeomQqOptions): import("./builder.js").GGBuilder;
+        geomQqLine(options?: import("./builder-options.js").GeomQqLineOptions): import("./builder.js").GGBuilder;
+        layer(layer: import("./normalize-input-layers-special.js").LayerInput): import("./builder.js").GGBuilder;
+    };
+} & typeof GGBuilderCore;
+/**
+ * Portable builder: `.spec()` and `.toPortable()` both normalize only.
+ * Full schema validation: import `validate` from `@ggts-sh/spec`.
+ */
+export declare class GGBuilder extends GGBuilder_base {
+    /** Normalize-only finish (TypeBox-free). Alias of {@link toPortable}. */
+    spec(): PortableSpec;
+}
+/** Start a plot for render paths: gg(data, aes(...)).geomPoint().spec(). */
+export declare function gg(data?: DataInput, mapping?: AesInput): GGBuilder;
+export {};
+//# sourceMappingURL=portable-builder.d.ts.map

package/dist/portable-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-builder.d.ts","sourceRoot":"","sources":["../src/portable-builder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGlD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,2EAA2E;AAC3E,wBAAgB,GAAG,CAAC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;GAGG;AACH,qBAAa,SAAU,SAAQ,cAAkD;IAC/E,yEAAyE;IACzE,IAAI,IAAI,YAAY;CAGrB;AAED,4EAA4E;AAC5E,wBAAgB,EAAE,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,SAAS,CAMlE"}

package/dist/portable-builder.js

@@ -0,0 +1,27 @@
+import { toAuthoringDataRef } from "./builder-data.js";
+import { GGBuilderCore } from "./builder-core.js";
+import { WithBuilderGeoms } from "./builder-geoms.js";
+import { WithBuilderScales } from "./builder-scales.js";
+/** Identity helper for aesthetic mappings (same as full package `aes`). */
+export function aes(mapping) {
+    return mapping;
+}
+/**
+ * Portable builder: `.spec()` and `.toPortable()` both normalize only.
+ * Full schema validation: import `validate` from `@ggts-sh/spec`.
+ */
+export class GGBuilder extends WithBuilderScales(WithBuilderGeoms(GGBuilderCore)) {
+    /** Normalize-only finish (TypeBox-free). Alias of {@link toPortable}. */
+    spec() {
+        return this.toPortable();
+    }
+}
+/** Start a plot for render paths: gg(data, aes(...)).geomPoint().spec(). */
+export function gg(data, mapping) {
+    return new GGBuilder({
+        ...(data !== undefined && { data: toAuthoringDataRef(data) }),
+        ...(mapping !== undefined && { aes: mapping }),
+        layers: [],
+    });
+}
+//# sourceMappingURL=portable-builder.js.map

package/dist/portable-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-builder.js","sourceRoot":"","sources":["../src/portable-builder.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,2EAA2E;AAC3E,MAAM,UAAU,GAAG,CAAC,OAAiB;IACnC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,SAAU,SAAQ,iBAAiB,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC/E,yEAAyE;IACzE,IAAI;QACF,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;CACF;AAED,4EAA4E;AAC5E,MAAM,UAAU,EAAE,CAAC,IAAgB,EAAE,OAAkB;IACrD,OAAO,IAAI,SAAS,CAAC;QACnB,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7D,GAAG,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;QAC9C,MAAM,EAAE,EAAE;KACX,CAAC,CAAC;AACL,CAAC"}

package/dist/portable-entry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lean portable builder entry (`@ggts-sh/spec/portable`).
+ *
+ * Exports the fluent builder without TypeBox: `.spec()` is an alias of
+ * `.toPortable()` (normalize only). Use this from chart render bundles;
+ * keep `@ggts-sh/spec` + `.spec()` / `validate()` for agent authoring.
+ *
+ * Lifecycle (Hadley lesson 13; meanings in CONTRIBUTING.md): tags collected
+ * into lifecycle.json by scripts/gen-lifecycle.ts.
+ */
+export type { AuthoringCellValue, AuthoringColumns, AuthoringDataRef, AuthoringRows, DataInput, } from "./builder-data.js";
+export type { GeomAreaOptions, GeomBarOptions, GeomBoxplotOptions, GeomColOptions, GeomDensityOptions, GeomHistogramOptions, GeomLineOptions, GeomPointOptions, GeomSmoothOptions, GeomTextOptions, } from "./builder-options.js";
+export { normalize } from "./normalize.js";
+export type { AesInput, SpecInput } from "./normalize.js";
+export { aes, gg, GGBuilder } from "./portable-builder.js";
+//# sourceMappingURL=portable-entry.d.ts.map

package/dist/portable-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-entry.d.ts","sourceRoot":"","sources":["../src/portable-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,SAAS,GACV,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/portable-entry.js

@@ -0,0 +1,14 @@
+/**
+ * Lean portable builder entry (`@ggts-sh/spec/portable`).
+ *
+ * Exports the fluent builder without TypeBox: `.spec()` is an alias of
+ * `.toPortable()` (normalize only). Use this from chart render bundles;
+ * keep `@ggts-sh/spec` + `.spec()` / `validate()` for agent authoring.
+ *
+ * Lifecycle (Hadley lesson 13; meanings in CONTRIBUTING.md): tags collected
+ * into lifecycle.json by scripts/gen-lifecycle.ts.
+ */
+// @lifecycle-default experimental
+export { normalize } from "./normalize.js";
+export { aes, gg, GGBuilder } from "./portable-builder.js";
+//# sourceMappingURL=portable-entry.js.map

package/dist/portable-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-entry.js","sourceRoot":"","sources":["../src/portable-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,kCAAkC;AAuBlC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/position-reference-build.d.ts

@@ -0,0 +1,29 @@
+/**
+ * POSITION_REFERENCE builder. Gen-only: `scripts/gen-reference-catalogs.ts`.
+ * Runtime uses generated/position-reference-data.ts.
+ */
+import { type GeomName, type PositionName } from "./schema-catalog.js";
+export interface PositionParamDoc {
+    readonly name: string;
+    readonly description: string;
+    readonly typeSummary: string;
+    readonly required: boolean;
+}
+export interface PositionReferenceEntry {
+    readonly name: PositionName;
+    /** Route slug — same as position name. */
+    readonly slug: string;
+    /** Short purpose text for the adjustment. */
+    readonly summary: string;
+    /**
+     * Keys of positionParams that apply to this position (from PositionParams
+     * schema, filtered by which adjustment uses them).
+     */
+    readonly params: readonly PositionParamDoc[];
+    /** Geoms whose layer schema allows this position. */
+    readonly compatibleGeoms: readonly GeomName[];
+    /** Geoms whose GEOM_DEFAULTS.position is this position. */
+    readonly defaultForGeoms: readonly GeomName[];
+}
+export declare function buildPositionReference(): Readonly<Record<PositionName, PositionReferenceEntry>>;
+//# sourceMappingURL=position-reference-build.d.ts.map