@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/spreadsheet-engine/datasource.js

@@ -119,6 +119,7 @@ export async function openDatasourceSession(capability, context) {
                         observed.delete(cell);
                     }
                 book = await recalculateWithDiagnostics(book, calculationContext, !linked);
+                tick();
                 linked = true;
                 if (!transport)
                     return book;
@@ -190,7 +191,9 @@ export async function openDatasourceSession(capability, context) {
                             tick();
                             return changed.has(JSON.stringify([sheet.id, cell.row, cell.column])) ? { ...cell, formulaDirty: true } : cell;
                         }) })) };
-                return await recalculateWithDiagnostics(dirty, calculationContext);
+                const result = await recalculateWithDiagnostics(dirty, calculationContext);
+                tick();
+                return result;
             }
             finally {
                 polling = false;

package/dist/spreadsheet-engine/formulas/functions/math.js

@@ -5,6 +5,7 @@ import { gamma } from "./scientific.js";
 import { capturedTrig } from "./captured-trigonometry.js";
 import { capturedExp } from "./numeric-arithmetic.js";
 import { preciseLog1p } from "./log1p.js";
+import { capturedAcos } from "./captured-acos.js";
 function fakeCeil(x) { return x === Math.floor(x) ? x : Math.ceil(nextAfter(x, -Infinity)); }
 function fakeRound(x) { return x === Math.floor(x) ? x : Math.sign(x) * fakeFloor(Math.abs(x) + .5); }
 function digitRound(x, digits, mode) {
@@ -125,7 +126,7 @@ export function preciseHypot(x, y, host) {
 const unary = {
     ABS: Math.abs, SIGN: Math.sign, SQRT: Math.sqrt, SQRTPI: x => Math.sqrt(Math.PI * x),
     INT: fakeFloor, CEIL: fakeCeil, SIN: Math.sin, COS: Math.cos, TAN: Math.tan,
-    ASIN: Math.asin, ACOS: Math.acos, ATAN: Math.atan, ACOT: x => Math.atan(1 / x),
+    ASIN: Math.asin, ATAN: Math.atan, ACOT: x => Math.atan(1 / x),
     SINH: Math.sinh, COSH: Math.cosh, TANH: Math.tanh, ASINH: Math.asinh, ACOSH: Math.acosh,
     ATANH: x => Math.abs(x) >= 1 ? NaN : Math.atanh(x), ACOTH: x => Math.abs(x) <= 1 ? NaN : Math.abs(x) > 2 ? Math.log1p(2 / (x - 1)) / 2 : Math.sign(x) * Math.log((Math.abs(x) - 1) / (Math.abs(x) + 1)) / -2,
     SEC: x => 1 / Math.cos(x), CSC: x => 1 / Math.sin(x), COT: x => 1 / Math.tan(x),
@@ -165,6 +166,7 @@ function binomial(n, k, host) {
 }
 export const mathFunctions = {
     ...Object.fromEntries(Object.entries(unary).map(([name, fn]) => [name, ((args, host) => numericResult(fn(numberArg(args, 0, host))))])),
+    ACOS: (args, host) => numericResult(capturedAcos(numberArg(args, 0, host), host)),
     LN1P: (args, host) => numericResult(preciseLog1p(numberArg(args, 0, host), host)),
     PI: () => numericResult(Math.PI),
     ATAN2: (args, host) => {

package/dist/spreadsheet-engine/rendering/chart/axis.d.ts

@@ -0,0 +1,26 @@
+/** Explicit-bound GogAxisMap behavior from GOffice 0.10.61 gog-axis.c.
+ * Date/time formats select other bound/tick algorithms, not other transforms.
+ * Bounds and spans must already have been resolved by the chart model.
+ */
+export interface AxisMapRequest {
+    readonly scale: "linear" | "category" | "logarithmic";
+    readonly minimum: number;
+    readonly maximum: number;
+    readonly offset: number;
+    readonly length: number;
+    readonly inverted?: boolean;
+    readonly circular?: boolean;
+    readonly spanStart?: number;
+    readonly spanEnd?: number;
+}
+export interface AxisMap {
+    readonly valid: boolean;
+    normalized(value: number): number;
+    toView(value: number): number;
+    fromView(value: number): number;
+    derivative(value: number): number;
+    isFinite(value: number): boolean;
+    baseline(): number;
+    bounds(): readonly [number, number];
+}
+export declare function createAxisMap(request: AxisMapRequest): AxisMap;

package/dist/spreadsheet-engine/rendering/chart/axis.js

@@ -0,0 +1,61 @@
+// go_rint uses the default nearest-even rounding mode, unlike Math.round.
+function nearestEven(value) {
+    const lower = Math.floor(value), fraction = value - lower;
+    const rounded = fraction < 0.5 ? lower : fraction > 0.5 ? lower + 1 : lower % 2 === 0 ? lower : lower + 1;
+    return rounded === 0 && value < 0 ? -0 : rounded;
+}
+export function createAxisMap(request) {
+    const log = request.scale === "logarithmic", category = request.scale === "category";
+    const inverted = request.inverted ?? false;
+    let offset = request.offset, length = request.length;
+    if (!request.circular) {
+        offset += (request.spanStart ?? 0) * length;
+        length *= (request.spanEnd ?? 1) - (request.spanStart ?? 0);
+    }
+    const valid = Number.isFinite(request.minimum) && Number.isFinite(request.maximum)
+        && request.minimum < request.maximum && (!log || request.minimum > 0);
+    const min = valid ? (log ? Math.log(request.minimum) : request.minimum) : 0;
+    const max = valid ? (log ? Math.log(request.maximum) : request.maximum) : log ? Math.log(10) : 1;
+    const scale = 1 / (max - min), a = scale * length;
+    const b = valid && (log || category) ? offset - a * min : offset;
+    const aInv = -scale * length, bInv = valid ? offset + length - aInv * min : offset + length;
+    function toView(value) {
+        if (log) {
+            if (value <= 0)
+                return inverted ? -Number.MAX_VALUE : Number.MAX_VALUE;
+            return inverted ? Math.log(value) * aInv + bInv : Math.log(value) * a + b;
+        }
+        if (category)
+            return (inverted ? min + max - value : value) * a + b;
+        return (inverted ? max - value : value - min) * a + b;
+    }
+    return Object.freeze({
+        valid,
+        normalized(value) {
+            const mapped = ((log ? Math.log(value) : value) - min) * scale;
+            return inverted ? 1 - mapped : mapped;
+        },
+        toView,
+        fromView(value) {
+            if (log)
+                return inverted ? Math.exp((value - bInv) / aInv) : Math.exp((value - b) / a);
+            if (category)
+                return nearestEven(inverted ? min + max - (value - b) / a : (value - b) / a);
+            return inverted ? max - (value - b) / a : (value - b) / a + min;
+        },
+        derivative(value) {
+            if (log)
+                return value <= 0 ? NaN : (inverted ? aInv : a) / value;
+            return inverted ? -a : a;
+        },
+        isFinite(value) { return Number.isFinite(value) && (!log || value > 0); },
+        baseline() {
+            if (log)
+                return inverted ? min * aInv + bInv : min * a + b;
+            // GOffice also uses map_linear_to_view for a discrete baseline.
+            const value = min > 0 ? min : max < 0 ? max : 0;
+            return (inverted ? max - value : value - min) * a + b;
+        },
+        bounds() { return log ? [Math.exp(min), Math.exp(max)] : [min, max]; }
+    });
+}

package/dist/spreadsheet-engine/rendering/chart/error-bar.d.ts

@@ -0,0 +1,39 @@
+import type { AxisMap } from "./axis.js";
+export interface ErrorBarData {
+    readonly type: "none" | "absolute" | "relative" | "percent";
+    /** Resolved valid series vector; absent/error entries are NaN. */
+    readonly values: readonly number[];
+    readonly positive?: readonly number[];
+    readonly negative?: readonly number[];
+}
+export interface ErrorBarBounds {
+    readonly minus: number;
+    readonly plus: number;
+}
+/** gog_error_bar_get_bounds, GOffice 0.10.61. Invalid errors are -1
+ * before relative/percent scaling, which can turn the sentinel into -0.
+ */
+export declare function errorBarBounds(data: ErrorBarData, index: number): ErrorBarBounds | undefined;
+export interface CartesianErrorBarRequest extends ErrorBarBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly direction: "horizontal" | "vertical";
+    readonly display: "none" | "positive" | "negative" | "both";
+    readonly xMap: AxisMap;
+    readonly yMap: AxisMap;
+    /** Widths in points; renderer scale is explicit, with no host discovery. */
+    readonly capWidth: number;
+    readonly lineWidth: number;
+    readonly pointsToX: number;
+    readonly pointsToY: number;
+}
+export interface ChartSegment {
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+}
+/** Cartesian branch of gog_error_bar_render. Clipping/paint is downstream;
+ * no clipping to axis bounds occurs here. Polar bars require another mapping.
+ */
+export declare function cartesianErrorBarSegments(request: CartesianErrorBarRequest): readonly ChartSegment[];

package/dist/spreadsheet-engine/rendering/chart/error-bar.js

@@ -0,0 +1,59 @@
+/** gog_error_bar_get_bounds, GOffice 0.10.61. Invalid errors are -1
+ * before relative/percent scaling, which can turn the sentinel into -0.
+ */
+export function errorBarBounds(data, index) {
+    if (index < 0 || !Number.isInteger(index))
+        return undefined;
+    const value = data.values[index];
+    if (data.type === "none" || value === undefined || !Number.isFinite(value))
+        return undefined;
+    const positive = data.positive, negative = data.negative;
+    let plus = positive?.[positive.length === 1 ? 0 : index] ?? -1;
+    let minus = negative === undefined || negative.length === 0 ? plus : negative[negative.length === 1 ? 0 : index] ?? -1;
+    if (!Number.isFinite(minus) || minus <= 0)
+        minus = -1;
+    if (!Number.isFinite(plus) || plus <= 0)
+        plus = -1;
+    if (data.type === "relative" || data.type === "percent") {
+        const scale = data.type === "relative" ? Math.abs(value) : Math.abs(value) / 100;
+        minus *= scale;
+        plus *= scale;
+    }
+    return { minus, plus };
+}
+/** Cartesian branch of gog_error_bar_render. Clipping/paint is downstream;
+ * no clipping to axis bounds occurs here. Polar bars require another mapping.
+ */
+export function cartesianErrorBarSegments(request) {
+    if (request.direction !== "horizontal" && request.direction !== "vertical")
+        return [];
+    const { x, y, minus, plus, xMap, yMap } = request;
+    const start = plus > 0 && (request.display === "positive" || request.display === "both");
+    const end = minus > 0 && (request.display === "negative" || request.display === "both");
+    if (!start && !end)
+        return [];
+    const horizontal = request.direction === "horizontal";
+    const map = horizontal ? xMap : yMap, value = horizontal ? x : y;
+    if (!xMap.isFinite(x) || !yMap.isFinite(y)
+        || (start && !map.isFinite(value + plus)) || (end && !map.isFinite(value - minus)))
+        return [];
+    const xView = xMap.toView(x), yView = yMap.toView(y);
+    const first = map.toView(start ? value + plus : value);
+    const last = map.toView(end ? value - minus : value);
+    const segments = [horizontal
+            ? { x1: first, y1: yView, x2: last, y2: yView }
+            : { x1: xView, y1: first, x2: xView, y2: last }];
+    const width = request.capWidth * (horizontal ? request.pointsToY : request.pointsToX) / 2;
+    const lineWidth = request.lineWidth * (horizontal ? request.pointsToX : request.pointsToY);
+    if (2 * width > lineWidth) {
+        if (start)
+            segments.push(horizontal
+                ? { x1: first, y1: yView - width, x2: first, y2: yView + width }
+                : { x1: xView - width, y1: first, x2: xView + width, y2: first });
+        if (end)
+            segments.push(horizontal
+                ? { x1: last, y1: yView - width, x2: last, y2: yView + width }
+                : { x1: xView - width, y1: last, x2: xView + width, y2: last });
+    }
+    return segments;
+}

package/dist/spreadsheet-engine/rendering/chart/layout.d.ts

@@ -0,0 +1,24 @@
+/** GOffice 0.10.61 go-geometry.c centered rectangles; angles in radians.
+ * Font shaping/measurement is a separate explicit host capability.
+ */
+export interface OrientedRectangle {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly angle: number;
+}
+export interface Rectangle {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export type LabelAnchor = "top-bottom" | "left-right";
+/** go_geometry_calc_label_position, relative to an axis tick at the origin. */
+export declare function positionLabel(box: OrientedRectangle, axisAngle: number, offset: number, side: "left" | "right", anchor?: LabelAnchor): {
+    readonly box: OrientedRectangle;
+    readonly anchor: LabelAnchor;
+};
+export declare function orientedBounds(box: OrientedRectangle): Rectangle;
+export declare function rectanglesOverlap(first: OrientedRectangle, second: OrientedRectangle): boolean;

package/dist/spreadsheet-engine/rendering/chart/layout.js

@@ -0,0 +1,54 @@
+/** go_geometry_calc_label_position, relative to an axis tick at the origin. */
+export function positionLabel(box, axisAngle, offset, side, anchor) {
+    if (side === "right")
+        axisAngle += Math.PI;
+    const s = Math.sin(box.angle - axisAngle), c = Math.cos(box.angle - axisAngle);
+    const dt = Math.abs(box.width * s / 2), ds = Math.abs(box.height * c / 2);
+    const resolved = anchor ?? (dt < ds ? "top-bottom" : "left-right");
+    let x, y;
+    if (resolved === "top-bottom") {
+        offset += dt;
+        x = box.height * Math.sin(box.angle) / 2;
+        y = -box.height * Math.cos(box.angle) / 2;
+        if (c < 0) {
+            x = -x;
+            y = -y;
+        }
+    }
+    else {
+        offset += ds;
+        x = -box.width * Math.cos(box.angle) / 2;
+        y = -box.width * Math.sin(box.angle) / 2;
+        if (s < 0) {
+            x = -x;
+            y = -y;
+        }
+    }
+    x += offset * Math.sin(axisAngle);
+    y += offset * -Math.cos(axisAngle);
+    return { box: { ...box, x, y }, anchor: resolved };
+}
+export function orientedBounds(box) {
+    const c = Math.cos(box.angle), s = Math.sin(box.angle);
+    const width = Math.abs(box.width * c) + Math.abs(box.height * s);
+    const height = Math.abs(box.width * s) + Math.abs(box.height * c);
+    return { x: box.x - width / 2, y: box.y - height / 2, width, height };
+}
+export function rectanglesOverlap(first, second) {
+    const c = Math.abs(Math.cos(second.angle - first.angle));
+    const s = Math.abs(Math.sin(second.angle - first.angle));
+    const dx = second.x - first.x, dy = second.y - first.y;
+    // Keep the native polar evaluation order, including boundary roundoff.
+    const distance = Math.hypot(dx, dy), angle = Math.atan2(dy, dx);
+    const a00 = Math.abs(first.width / 2), a01 = Math.abs(first.height / 2);
+    const a10 = Math.abs(second.width / 2), a11 = Math.abs(second.height / 2);
+    if (Math.abs(distance * Math.cos(angle - first.angle)) > a00 + (a10 * c + a11 * s))
+        return false;
+    if (Math.abs(distance * Math.sin(angle - first.angle)) > a01 + (a10 * s + a11 * c))
+        return false;
+    if (Math.abs(distance * Math.cos(second.angle - angle)) > a00 * c + a01 * s + a10)
+        return false;
+    if (Math.abs(distance * Math.sin(second.angle - angle)) > a00 * s + a01 * c + a11)
+        return false;
+    return true;
+}

package/dist/spreadsheet-engine/rendering/chart/line.d.ts

@@ -0,0 +1,23 @@
+import { type CapabilityContext } from "../../contracts.js";
+import type { AxisMap } from "./axis.js";
+export type CartesianInterpolation = "linear" | "step-start" | "step-end" | "step-center-x" | "step-center-y";
+export interface CartesianSeriesRequest {
+    readonly count: number;
+    readonly x?: readonly number[];
+    readonly y?: readonly number[];
+    readonly xMap: AxisMap;
+    readonly yMap: AxisMap;
+    readonly interpolation: CartesianInterpolation;
+    readonly skipInvalid: boolean;
+}
+export interface SeriesPathCommand {
+    readonly kind: "move" | "line";
+    readonly x: number;
+    readonly y: number;
+}
+/** GOffice 0.10.61 make_path_linear (Cartesian) and xy_make_path_step.
+ * Step paths have GO_PATH_OPTIONS_SHARP; callers must retain sharp corners.
+ * Missing vectors use one-based indices; invalid mapped values break/skip paths.
+ * Splines, polar paths, fill closure and stroke styles are separate stages.
+ */
+export declare function cartesianSeriesPath(request: CartesianSeriesRequest, context: CapabilityContext): Generator<SeriesPathCommand>;

package/dist/spreadsheet-engine/rendering/chart/line.js

@@ -0,0 +1,56 @@
+import { SsconvertError } from "../../contracts.js";
+/** GOffice 0.10.61 make_path_linear (Cartesian) and xy_make_path_step.
+ * Step paths have GO_PATH_OPTIONS_SHARP; callers must retain sharp corners.
+ * Missing vectors use one-based indices; invalid mapped values break/skip paths.
+ * Splines, polar paths, fill closure and stroke styles are separate stages.
+ */
+export function* cartesianSeriesPath(request, context) {
+    context.signal.throwIfAborted();
+    if (!Number.isSafeInteger(request.count) || request.count < 0)
+        throw new SsconvertError("invalid-request", "ssconvert invalid chart point count");
+    if (!["linear", "step-start", "step-end", "step-center-x", "step-center-y"].includes(request.interpolation)) {
+        throw new SsconvertError("unsupported-feature", "ssconvert unsupported chart interpolation");
+    }
+    const maximum = context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32;
+    let work = 0, valid = false, lastX = 0, lastY = 0;
+    for (let index = 0; index < request.count; index++) {
+        context.signal.throwIfAborted();
+        if (++work > maximum)
+            throw new SsconvertError("resource-limit", "ssconvert chart work limit exceeded");
+        const x = request.xMap.toView(request.x === undefined ? index + 1 : request.x[index] ?? NaN);
+        const y = request.yMap.toView(request.y === undefined ? index + 1 : request.y[index] ?? NaN);
+        if (!Number.isFinite(x) || !Number.isFinite(y) || Math.abs(x) === Number.MAX_VALUE || Math.abs(y) === Number.MAX_VALUE) {
+            if (!request.skipInvalid)
+                valid = false;
+            continue;
+        }
+        if (!valid)
+            yield { kind: "move", x, y };
+        else {
+            switch (request.interpolation) {
+                case "step-start":
+                    yield { kind: "line", x, y: lastY };
+                    break;
+                case "step-end":
+                    yield { kind: "line", x: lastX, y };
+                    break;
+                case "step-center-x":
+                    yield { kind: "line", x: (lastX + x) / 2, y: lastY };
+                    context.signal.throwIfAborted();
+                    yield { kind: "line", x: (lastX + x) / 2, y };
+                    break;
+                case "step-center-y":
+                    yield { kind: "line", x: lastX, y: (lastY + y) / 2 };
+                    context.signal.throwIfAborted();
+                    yield { kind: "line", x, y: (lastY + y) / 2 };
+                    break;
+            }
+            context.signal.throwIfAborted();
+            yield { kind: "line", x, y };
+        }
+        valid = true;
+        lastX = x;
+        lastY = y;
+    }
+    context.signal.throwIfAborted();
+}

package/dist/spreadsheet-engine/rendering/chart/marker.d.ts

@@ -0,0 +1,35 @@
+export type MarkerCommand = readonly ["M" | "L", number, number] | readonly ["C", number, number, number, number, number, number] | readonly ["Z"];
+declare const shapes: {
+    readonly none: readonly [];
+    readonly square: readonly MarkerCommand[];
+    readonly diamond: readonly [readonly ["M", 0, -1], readonly ["L", 1, 0], readonly ["L", 0, 1], readonly ["L", -1, 0], readonly ["Z"]];
+    readonly "triangle-down": readonly [readonly ["M", -1, -1], readonly ["L", 1, -1], readonly ["L", 0, 1], readonly ["Z"]];
+    readonly "triangle-up": readonly [readonly ["M", 0, -1], readonly ["L", 1, 1], readonly ["L", -1, 1], readonly ["Z"]];
+    readonly "triangle-right": readonly [readonly ["M", -1, -1], readonly ["L", 1, 0], readonly ["L", -1, 1], readonly ["Z"]];
+    readonly "triangle-left": readonly [readonly ["M", 1, -1], readonly ["L", -1, 0], readonly ["L", 1, 1], readonly ["Z"]];
+    readonly circle: readonly [readonly ["M", 1, 0], readonly ["C", 1, 0.56, 0.56, 1, 0, 1], readonly ["C", -0.56, 1, -1, 0.56, -1, 0], readonly ["C", -1, -0.56, -0.56, -1, 0, -1], readonly ["C", 0.56, -1, 1, -0.56, 1, 0], readonly ["L", 1, 0], readonly ["Z"]];
+    readonly x: readonly [readonly ["M", 1, 1], readonly ["L", -1, -1], readonly ["M", 1, -1], readonly ["L", -1, 1]];
+    readonly cross: readonly [readonly ["M", 1, 0], readonly ["L", -1, 0], readonly ["M", 0, 1], readonly ["L", 0, -1]];
+    readonly asterisk: readonly [readonly ["M", 0.7, 0.7], readonly ["L", -0.7, -0.7], readonly ["M", 0.7, -0.7], readonly ["L", -0.7, 0.7], readonly ["M", 1, 0], readonly ["L", -1, 0], readonly ["M", 0, 1], readonly ["L", 0, -1]];
+    readonly bar: readonly [readonly ["M", -1, -0.2], readonly ["L", 1, -0.2], readonly ["L", 1, 0.2], readonly ["L", -1, 0.2], readonly ["Z"]];
+    readonly "half-bar": readonly [readonly ["M", 0, -0.2], readonly ["L", 1, -0.2], readonly ["L", 1, 0.2], readonly ["L", 0, 0.2], readonly ["Z"]];
+    readonly butterfly: readonly [readonly ["M", -1, -1], readonly ["L", -1, 1], readonly ["L", 0, 0], readonly ["L", 1, 1], readonly ["L", 1, -1], readonly ["L", 0, 0], readonly ["Z"]];
+    readonly hourglass: readonly [readonly ["M", -1, -1], readonly ["L", 1, -1], readonly ["L", 0, 0], readonly ["L", 1, 1], readonly ["L", -1, 1], readonly ["L", 0, 0], readonly ["Z"]];
+    readonly "lefthalf-bar": readonly [readonly ["M", 0, -0.2], readonly ["L", -1, -0.2], readonly ["L", -1, 0.2], readonly ["L", 0, 0.2], readonly ["Z"]];
+};
+export type MarkerShape = keyof typeof shapes;
+export interface MarkerGeometry {
+    readonly shape: MarkerShape;
+    readonly closed: boolean;
+    readonly outline: readonly MarkerCommand[];
+    readonly fill: readonly MarkerCommand[];
+    readonly strokeWidth: number;
+    readonly lineCap: "square";
+    readonly lineJoin: "miter";
+}
+/** GOffice 0.10.61 marker path/scaling stage, independent of painting and codec.
+ * Size is the resolved nonnegative native integer size. Surface pixel rounding
+ * and paint/color resolution are separate stages, not approximated here.
+ */
+export declare function markerGeometry(name: string, size: number, x: number, y: number, scale: number): MarkerGeometry;
+export {};

package/dist/spreadsheet-engine/rendering/chart/marker.js

@@ -0,0 +1,52 @@
+// Normalized go-marker.c paths. Crossed shapes have a distinct square fill.
+const square = [["M", -1, -1], ["L", -1, 1], ["L", 1, 1], ["L", 1, -1], ["Z"]];
+const shapes = {
+    none: [],
+    square,
+    diamond: [["M", 0, -1], ["L", 1, 0], ["L", 0, 1], ["L", -1, 0], ["Z"]],
+    "triangle-down": [["M", -1, -1], ["L", 1, -1], ["L", 0, 1], ["Z"]],
+    "triangle-up": [["M", 0, -1], ["L", 1, 1], ["L", -1, 1], ["Z"]],
+    "triangle-right": [["M", -1, -1], ["L", 1, 0], ["L", -1, 1], ["Z"]],
+    "triangle-left": [["M", 1, -1], ["L", -1, 0], ["L", 1, 1], ["Z"]],
+    circle: [["M", 1, 0], ["C", 1, 0.56, 0.56, 1, 0, 1], ["C", -0.56, 1, -1, 0.56, -1, 0],
+        ["C", -1, -0.56, -0.56, -1, 0, -1], ["C", 0.56, -1, 1, -0.56, 1, 0], ["L", 1, 0], ["Z"]],
+    x: [["M", 1, 1], ["L", -1, -1], ["M", 1, -1], ["L", -1, 1]],
+    cross: [["M", 1, 0], ["L", -1, 0], ["M", 0, 1], ["L", 0, -1]],
+    asterisk: [["M", 0.7, 0.7], ["L", -0.7, -0.7], ["M", 0.7, -0.7], ["L", -0.7, 0.7],
+        ["M", 1, 0], ["L", -1, 0], ["M", 0, 1], ["L", 0, -1]],
+    bar: [["M", -1, -0.2], ["L", 1, -0.2], ["L", 1, 0.2], ["L", -1, 0.2], ["Z"]],
+    "half-bar": [["M", 0, -0.2], ["L", 1, -0.2], ["L", 1, 0.2], ["L", 0, 0.2], ["Z"]],
+    butterfly: [["M", -1, -1], ["L", -1, 1], ["L", 0, 0], ["L", 1, 1], ["L", 1, -1], ["L", 0, 0], ["Z"]],
+    hourglass: [["M", -1, -1], ["L", 1, -1], ["L", 0, 0], ["L", 1, 1], ["L", -1, 1], ["L", 0, 0], ["Z"]],
+    "lefthalf-bar": [["M", 0, -0.2], ["L", -1, -0.2], ["L", -1, 0.2], ["L", 0, 0.2], ["Z"]]
+};
+/** GOffice 0.10.61 marker path/scaling stage, independent of painting and codec.
+ * Size is the resolved nonnegative native integer size. Surface pixel rounding
+ * and paint/color resolution are separate stages, not approximated here.
+ */
+export function markerGeometry(name, size, x, y, scale) {
+    const shape = Object.keys(shapes).find(candidate => {
+        if (candidate.length !== name.length)
+            return false;
+        for (let index = 0; index < candidate.length; index++) {
+            const code = name.charCodeAt(index);
+            if ((code >= 65 && code <= 90 ? code + 32 : code) !== candidate.charCodeAt(index))
+                return false;
+        }
+        return true;
+    }) ?? "none";
+    const halfSize = 0.5 * scale * size;
+    const closed = shape !== "x" && shape !== "cross" && shape !== "asterisk";
+    function transform(commands) {
+        return commands.map(command => {
+            if (command[0] === "Z")
+                return ["Z"];
+            if (command[0] === "C")
+                return ["C", x + command[1] * halfSize, y + command[2] * halfSize,
+                    x + command[3] * halfSize, y + command[4] * halfSize, x + command[5] * halfSize, y + command[6] * halfSize];
+            return [command[0], x + command[1] * halfSize, y + command[2] * halfSize];
+        });
+    }
+    return { shape, closed, outline: transform(shapes[shape]), fill: transform(closed ? shapes[shape] : square),
+        strokeWidth: Math.abs(halfSize) * (2 * 0.1), lineCap: "square", lineJoin: "miter" };
+}

package/dist/spreadsheet-engine/rendering/chart/pie.d.ts

@@ -0,0 +1,32 @@
+import { type CapabilityContext } from "../../contracts.js";
+/** Resolved single-ring allocation. Radius fitting, outlines, styles and labels
+ * are deliberately outside this wedge stage, as in gog_pie_view_render.
+ */
+export interface PieGeometryRequest {
+    readonly values: readonly number[];
+    readonly negativeMode: "skip" | "absolute" | "white";
+    readonly centerX: number;
+    readonly centerY: number;
+    readonly radius: number;
+    readonly innerRadius: number;
+    /** Combined plot/series initial angle in degrees. */
+    readonly initialAngle: number;
+    /** Plot span in percent of a full circle. */
+    readonly span: number;
+    /** Default separation as a fraction of total radius, outer ring only. */
+    readonly separation: number;
+    /** Resolved per-element separation overrides for the outer ring. */
+    readonly elementSeparation?: ReadonlyMap<number, number>;
+}
+export interface PieWedge {
+    readonly index: number;
+    readonly whiteFill: boolean;
+    readonly centerX: number;
+    readonly centerY: number;
+    readonly radius: number;
+    readonly innerRadius: number;
+    readonly startAngle: number;
+    readonly endAngle: number;
+}
+/** GOffice 0.10.61 gog_pie_series_update and wedge loop, codec independent. */
+export declare function pieWedges(request: PieGeometryRequest, context: CapabilityContext): Generator<PieWedge>;

package/dist/spreadsheet-engine/rendering/chart/pie.js

@@ -0,0 +1,47 @@
+import { SsconvertError } from "../../contracts.js";
+/** GOffice 0.10.61 gog_pie_series_update and wedge loop, codec independent. */
+export function* pieWedges(request, context) {
+    let work = 0;
+    const maximum = context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32;
+    function charge() {
+        context.signal.throwIfAborted();
+        if (++work > maximum)
+            throw new SsconvertError("resource-limit", "ssconvert chart work limit exceeded");
+    }
+    charge();
+    let total = 0;
+    // The native total is accumulated in reverse data order.
+    for (let index = request.values.length; index-- > 0;) {
+        charge();
+        const value = request.values[index];
+        if (Number.isFinite(value))
+            total += value < 0 ? request.negativeMode === "skip" ? 0 : -value : value;
+    }
+    const scale = 2 * Math.PI / 100 * request.span / total;
+    let theta = request.initialAngle * Math.PI / 180 - Math.PI / 2;
+    const defaultSeparation = request.radius * request.separation;
+    for (let index = 0; index < request.values.length; index++) {
+        charge();
+        let length = request.values[index] * scale;
+        const negative = length < 0;
+        if (negative) {
+            if (request.negativeMode === "skip")
+                continue;
+            length = -length;
+        }
+        if (!Number.isFinite(length) || length < 1e-3)
+            continue;
+        const override = request.elementSeparation?.get(index);
+        let centerX = request.centerX, centerY = request.centerY;
+        if (defaultSeparation > 0 || override !== undefined) {
+            const separation = defaultSeparation + (override ?? 0) * request.radius;
+            centerX += separation * Math.cos(theta + length / 2);
+            centerY += separation * Math.sin(theta + length / 2);
+        }
+        theta += length;
+        yield { index, whiteFill: negative && request.negativeMode === "white", centerX, centerY,
+            radius: request.radius, innerRadius: request.innerRadius > 0 ? request.innerRadius : 0,
+            startAngle: theta - length, endAngle: theta };
+    }
+    context.signal.throwIfAborted();
+}

package/dist/{safe-bash-command-ssconvert → spreadsheet-engine}/rendering/images/codecs.d.ts

@@ -50,4 +50,3 @@ export interface ImageSurface {
     };
 }
 export declare function encodeGraphImage(surface: ImageSurface, format: string, context: CapabilityContext): Promise<Uint8Array>;
-//# sourceMappingURL=codecs.d.ts.map