weasel-icons 0.17.0 → 0.18.0

package/dist/icons/brain-computer-interface/brain-computer-interface-rig.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The implant itself, in cross-section. The upper curve of the brain fills the lower canvas: a
+ * bold outline of five gyri meeting at sulcus cusps, over a light tissue tint. A flat implant
+ * chip sits on the crown of the middle gyrus and three flexible electrode threads (drawn faint,
+ * inside the tissue) run down from it. Spikes climb the threads into the chip; the chip then
+ * lights and transmits wirelessly as two arcs radiating up from it.
+ */
+export declare const brainComputerInterfaceStates: readonly ["idle", "recording", "transmitting"];
+export type BrainComputerInterfaceState = (typeof brainComputerInterfaceStates)[number];
+export declare const brainComputerInterfaceArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        accent: boolean;
+        pivot: readonly [number, number];
+        poses: ({
+            opacity: number;
+        } | {
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            interpolation: "continuous";
+            frames: {
+                at: number;
+                x: number;
+                y: number;
+                opacity: number;
+            }[];
+            duration: number;
+            repeatAfter: number;
+        } | null)[];
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        poses: {
+            opacity: number;
+        }[];
+        detail?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        poses: {}[];
+        fillOnly?: undefined;
+        detail?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        detail: true;
+        poses: {
+            opacity: number;
+        }[];
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        poses: {}[];
+        detail?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: [number, number];
+        poses: ({
+            opacity: number;
+            scaleX: number;
+        } | {
+            opacity?: undefined;
+            scaleX?: undefined;
+        })[];
+        detail?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        accent: true;
+        pivot: readonly [number, number];
+        poses: {}[];
+        gestures: ({
+            frames: ({
+                at: number;
+                opacity?: undefined;
+                scaleX?: undefined;
+                scaleY?: undefined;
+            } | {
+                at: number;
+                opacity: number;
+                scaleX: number;
+                scaleY: number;
+            })[];
+            duration: number;
+            repeatAfter: number;
+        } | null)[];
+        fillOnly?: undefined;
+        detail?: undefined;
+    })[];
+};

package/dist/icons/brain-computer-interface/brain-computer-interface-rig.js

@@ -0,0 +1,177 @@
+/**
+ * The implant itself, in cross-section. The upper curve of the brain fills the lower canvas: a
+ * bold outline of five gyri meeting at sulcus cusps, over a light tissue tint. A flat implant
+ * chip sits on the crown of the middle gyrus and three flexible electrode threads (drawn faint,
+ * inside the tissue) run down from it. Spikes climb the threads into the chip; the chip then
+ * lights and transmits wirelessly as two arcs radiating up from it.
+ */
+export const brainComputerInterfaceStates = ['idle', 'recording', 'transmitting'];
+const n = (v) => +v.toFixed(3);
+/** Rounded rectangle with cubic corners. */
+const rr = (x1, y1, x2, y2, r) => {
+    const k = n(0.5523 * r);
+    return (`M${n(x1 + r)} ${y1}H${n(x2 - r)}C${n(x2 - r + k)} ${y1} ${x2} ${n(y1 + r - k)} ${x2} ${n(y1 + r)}` +
+        `V${n(y2 - r)}C${x2} ${n(y2 - r + k)} ${n(x2 - r + k)} ${y2} ${n(x2 - r)} ${y2}` +
+        `H${n(x1 + r)}C${n(x1 + r - k)} ${y2} ${x1} ${n(y2 - r + k)} ${x1} ${n(y2 - r)}` +
+        `V${n(y1 + r)}C${x1} ${n(y1 + r - k)} ${n(x1 + r - k)} ${y1} ${n(x1 + r)} ${y1}Z`);
+};
+// Cortex: the upper curve of the brain in section, five gyri meeting at sulcus cusps, with the
+// chip on the crown of the middle one.
+const DOME = { cx: 12, cy: 22.4, rx: 9.2, ry: 10.4, bump: 1.7, gyrus: 36 };
+const SURFACE = (() => {
+    const steps = 90;
+    const pts = Array.from({ length: steps + 1 }, (_, i) => {
+        const th = 180 - (180 * i) / steps;
+        const b = Math.sqrt(Math.abs(Math.cos((Math.PI * (th - 90)) / DOME.gyrus)));
+        const k = 1 + (DOME.bump * b) / DOME.ry;
+        const x = DOME.cx + DOME.rx * k * Math.cos((th * Math.PI) / 180);
+        const y = DOME.cy - DOME.ry * k * Math.sin((th * Math.PI) / 180);
+        return `${n(x)} ${n(Math.min(y, 21.6))}`;
+    });
+    return `M${pts[0]}L${pts.slice(1).join('L')}`;
+})();
+/** The tissue under the surface, cut off by the frame of the section. */
+const TISSUE = `${SURFACE}Z`;
+// Chip seated on the crown of the middle gyrus.
+const CHIP = { x1: 8.6, y1: 7.2, x2: 15.4, y2: 10.4 };
+const END = 18.2;
+const THREADS = [
+    { x0: 10.2, dx: -1.6, sway: 0.3 },
+    { x0: 12, dx: 0, sway: -0.3 },
+    { x0: 13.8, dx: 1.6, sway: 0.3 },
+];
+const threadX = (t, y) => {
+    const u = (y - CHIP.y2) / (END - CHIP.y2);
+    return t.x0 + t.dx * u + t.sway * Math.sin(Math.PI * 2 * u);
+};
+const threadPath = (t) => {
+    const steps = 10;
+    const pts = Array.from({ length: steps + 1 }, (_, i) => {
+        const y = CHIP.y2 + ((END - CHIP.y2) * i) / steps;
+        return `${n(threadX(t, y))} ${n(y)}`;
+    });
+    return `M${pts[0]}L${pts.slice(1).join('L')}`;
+};
+const SPIKE_HALF = 0.75;
+const BURST = { duration: 2.4, repeatAfter: 3.2 };
+// Spike centres climb from near the thread tip to just under the chip.
+const RUN = [CHIP.y2 + 1.1, END - 0.6];
+/**
+ * Constant-speed climb along a thread from the rest centre c: up to the chip, wrap to the
+ * thread tip, back to c. The x offset follows the thread's sway so the spike stays on it.
+ */
+function climb(t, c) {
+    const len = RUN[1] - RUN[0];
+    const ahead = c - RUN[0];
+    const fade = (y) => {
+        const e = Math.max(0, Math.min(1, Math.min(y - RUN[0], RUN[1] - y) / 1.1));
+        return e * e * (3 - 2 * e);
+    };
+    const wrap = ahead / len;
+    const pos = (u) => {
+        const d = u * len;
+        return d <= ahead ? c - d : RUN[1] - (d - ahead);
+    };
+    const cx = threadX(t, c);
+    const frame = (when, y, opacity) => ({
+        at: n(when),
+        x: n(threadX(t, y) - cx),
+        y: n(y - c),
+        opacity: n(opacity),
+    });
+    const times = Array.from({ length: 25 }, (_, i) => i / 24).filter((u) => Math.abs(u - wrap) > 0.02);
+    const frames = times.map((u) => frame(u, pos(u), fade(pos(u)) - fade(c)));
+    frames.push(frame(wrap - 0.004, RUN[0], -1), frame(wrap + 0.004, RUN[1], -1));
+    frames.sort((a, b) => a.at - b.at);
+    frames[0] = { at: 0, x: 0, y: 0, opacity: 0 };
+    frames[frames.length - 1] = { at: 1, x: 0, y: 0, opacity: 0 };
+    return { ...BURST, interpolation: 'continuous', frames };
+}
+const spikePart = (name, t, c) => {
+    const x = n(threadX(t, c));
+    return {
+        name,
+        paths: [`M${x} ${n(c - SPIKE_HALF)}V${n(c + SPIKE_HALF)}`],
+        accent: true,
+        pivot: [x, c],
+        poses: [{ opacity: 0 }, {}, { opacity: 0 }],
+        gestures: [null, climb(t, c), null],
+    };
+};
+// Wireless arcs: concentric about a point inside the chip.
+const ARC_C = [12, 8.8];
+const arc = (r, half) => {
+    const a = (half * Math.PI) / 180;
+    const dx = n(r * Math.sin(a));
+    const dy = n(r * Math.cos(a));
+    return `M${n(ARC_C[0] - dx)} ${n(ARC_C[1] - dy)}A${r} ${r} 0 0 1 ${n(ARC_C[0] + dx)} ${n(ARC_C[1] - dy)}`;
+};
+/** A pulse leaving the chip: the arc fades, then grows back out from the chip. */
+const pulse = (start) => ({
+    ...BURST,
+    frames: [
+        { at: 0 },
+        { at: start, opacity: -1, scaleX: -0.3, scaleY: -0.3 },
+        { at: n(start + 0.35) },
+        { at: 1 },
+    ],
+});
+const hidden = { opacity: 0, scaleX: 0.7, scaleY: 0.7 };
+export const brainComputerInterfaceArt = {
+    name: 'brain-computer-interface',
+    parts: [
+        {
+            // The tissue below the surface, as a light tint down to the bottom of the canvas.
+            name: 'tissue',
+            paths: [TISSUE],
+            fillOnly: 'ink',
+            poses: [{ opacity: 0.22 }, { opacity: 0.22 }, { opacity: 0.22 }],
+        },
+        {
+            // The folded cortex surface.
+            name: 'cortex',
+            paths: [SURFACE],
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'threads',
+            paths: [THREADS.map(threadPath).join('')],
+            detail: true,
+            poses: [{ opacity: 0.5 }, { opacity: 0.5 }, { opacity: 0.5 }],
+        },
+        spikePart('spike-a', THREADS[0], 13.2),
+        spikePart('spike-b', THREADS[1], 15.4),
+        spikePart('spike-c', THREADS[2], 14.4),
+        {
+            name: 'chip',
+            paths: [rr(CHIP.x1, CHIP.y1, CHIP.x2, CHIP.y2, 1)],
+            fillOnly: 'ink',
+            poses: [{}, {}, {}],
+        },
+        {
+            // Lit when the chip is sending: the interior fills with the accent.
+            name: 'chip-light',
+            paths: [rr(CHIP.x1 + 0.8, CHIP.y1 + 0.8, CHIP.x2 - 0.8, CHIP.y2 - 0.8, 0.4)],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: [12, (CHIP.y1 + CHIP.y2) / 2],
+            poses: [{ opacity: 0, scaleX: 0.3 }, { opacity: 0, scaleX: 0.3 }, {}],
+        },
+        {
+            name: 'arc-inner',
+            paths: [arc(4.4, 34)],
+            accent: true,
+            pivot: ARC_C,
+            poses: [hidden, hidden, {}],
+            gestures: [null, null, pulse(0.08)],
+        },
+        {
+            name: 'arc-outer',
+            paths: [arc(7.2, 34)],
+            accent: true,
+            pivot: ARC_C,
+            poses: [hidden, hidden, {}],
+            gestures: [null, null, pulse(0.3)],
+        },
+    ],
+};

package/dist/icons/carbon-capture/carbon-capture-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type CarbonCaptureState } from "./carbon-capture-rig.js";
+export { carbonCaptureStates, type CarbonCaptureState } from "./carbon-capture-rig.js";
+export type CarbonCaptureIconProps = StatefulIconProps<CarbonCaptureState>;
+export declare const CarbonCaptureIcon: import("react").NamedExoticComponent<CarbonCaptureIconProps>;

package/dist/icons/carbon-capture/carbon-capture-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { carbonCaptureArt, carbonCaptureStates, } from "./carbon-capture-rig.js";
+export { carbonCaptureStates } from "./carbon-capture-rig.js";
+export const CarbonCaptureIcon = memo(function CarbonCaptureIcon(props) {
+    return _jsx(ArticulatedIcon, { art: carbonCaptureArt, states: carbonCaptureStates, ...props });
+});

package/dist/icons/carbon-capture/carbon-capture-rig.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Direct air capture with geological storage, as a cross-section. A fan-driven capture unit
+ * stands on the ground and pulls an O=C=O molecule out of the air. Below the surface is solid
+ * rock; the captured CO2 runs down the injection well into a porous storage layer (the white
+ * cavity under a thick caprock) and spreads sideways from the well until the layer is full.
+ */
+export declare const carbonCaptureStates: readonly ["airborne", "capturing", "stored"];
+export type CarbonCaptureState = (typeof carbonCaptureStates)[number];
+export declare const carbonCaptureArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        poses: ({
+            x?: undefined;
+            opacity?: undefined;
+        } | {
+            x: number;
+            opacity?: undefined;
+        } | {
+            x: number;
+            opacity: number;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            frames: ({
+                at: number;
+                x?: undefined;
+                opacity?: undefined;
+            } | {
+                at: number;
+                x: number;
+                opacity?: undefined;
+            } | {
+                at: number;
+                x: number;
+                opacity: number;
+            })[];
+        } | null)[];
+        surface?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        surface: true;
+        poses: {}[];
+        fillOnly?: undefined;
+        accent?: undefined;
+        gestures?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        pivot: readonly [number, number];
+        spin: {
+            state: number;
+            degreesPerSecond: number;
+        };
+        poses: {}[];
+        accent?: undefined;
+        gestures?: undefined;
+        surface?: undefined;
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        poses: {}[];
+        accent?: undefined;
+        gestures?: undefined;
+        surface?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "surface";
+        poses: {}[];
+        accent?: undefined;
+        gestures?: undefined;
+        surface?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        pathStates: string[][];
+        pathOffsets: number[][];
+        fillOnly: "ink";
+        accent: true;
+        poses: ({
+            opacity: number;
+        } | {
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                flex: number;
+            } | {
+                at: number;
+                flex?: undefined;
+            })[];
+        } | null)[];
+        surface?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: [number, number];
+        poses: ({
+            scaleY: number;
+            opacity: number;
+        } | {
+            scaleY?: undefined;
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            frames: ({
+                at: number;
+                opacity?: undefined;
+                scaleY?: undefined;
+            } | {
+                at: number;
+                opacity: number;
+                scaleY?: undefined;
+            } | {
+                at: number;
+                opacity: number;
+                scaleY: number;
+            } | {
+                at: number;
+                scaleY: number;
+                opacity?: undefined;
+            })[];
+        } | null)[];
+        surface?: undefined;
+        spin?: undefined;
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+    })[];
+};

package/dist/icons/carbon-capture/carbon-capture-rig.js

@@ -0,0 +1,173 @@
+/**
+ * Direct air capture with geological storage, as a cross-section. A fan-driven capture unit
+ * stands on the ground and pulls an O=C=O molecule out of the air. Below the surface is solid
+ * rock; the captured CO2 runs down the injection well into a porous storage layer (the white
+ * cavity under a thick caprock) and spreads sideways from the well until the layer is full.
+ */
+export const carbonCaptureStates = ['airborne', 'capturing', 'stored'];
+const n = (v) => +v.toFixed(3);
+/** Cubic circle. */
+const disc = (cx, cy, r) => {
+    const k = 0.5523 * r;
+    return (`M${n(cx + r)} ${n(cy)}C${n(cx + r)} ${n(cy + k)} ${n(cx + k)} ${n(cy + r)} ${n(cx)} ${n(cy + r)}` +
+        `C${n(cx - k)} ${n(cy + r)} ${n(cx - r)} ${n(cy + k)} ${n(cx - r)} ${n(cy)}` +
+        `C${n(cx - r)} ${n(cy - k)} ${n(cx - k)} ${n(cy - r)} ${n(cx)} ${n(cy - r)}` +
+        `C${n(cx + k)} ${n(cy - r)} ${n(cx + r)} ${n(cy - k)} ${n(cx + r)} ${n(cy)}Z`);
+};
+/** Horizontal pill with cubic ends; morph-safe (no arcs). */
+const pill = (left, right, top, bottom) => {
+    const h = (bottom - top) / 2;
+    const k = n(0.5523 * h);
+    const m = n(top + h);
+    return (`M${n(left + h)} ${top}H${n(right - h)}C${n(right - h + k)} ${top} ${right} ${n(m - k)} ${right} ${m}` +
+        `C${right} ${n(m + k)} ${n(right - h + k)} ${bottom} ${n(right - h)} ${bottom}H${n(left + h)}` +
+        `C${n(left + h - k)} ${bottom} ${left} ${n(m + k)} ${left} ${m}C${left} ${n(m - k)} ${n(left + h - k)} ${top} ${n(left + h)} ${top}Z`);
+};
+/** Ground surface: the top of the rock. */
+const GROUND = 12.8;
+const UNIT = { left: 11.2, top: 2.6, right: 21.4, r: 1.8 };
+const FAN = [16.3, 7.9];
+const BLADE = 3;
+const MOLECULE_Y = FAN[1];
+/** Capturing: the molecule is half inside the unit's intake face. */
+const INTAKE = 3.6;
+/** Fully behind the unit's face. */
+const SWALLOWED = 9.4;
+const WELL_X = FAN[0];
+const WELL_HALF = 1;
+const LAYER = { left: 4.2, right: 19.8, top: 16.2, bottom: 19.8 };
+const layer = (left) => pill(left, LAYER.right, LAYER.top, LAYER.bottom);
+const EMPTY_LEFT = LAYER.right - (LAYER.bottom - LAYER.top);
+const NUMBERS = /[-+]?(?:\d*\.\d+|\d+\.?\d*)/g;
+/** Flex 1 pulls the CO2's far edge all the way back to the well end of the layer. */
+const RETRACT = ((a, b) => {
+    const to = a.match(NUMBERS).map(Number);
+    return b.match(NUMBERS).map((v, i) => n(to[i] - Number(v)));
+})(layer(EMPTY_LEFT), layer(LAYER.left));
+// Spread slowly after the state change instead of riding the 0.4 s state spring. These flex
+// values cancel most of the spring's path blend from the usual neighbouring state.
+const HOLD_STORED = n((10.6 - LAYER.left) / (EMPTY_LEFT - LAYER.left));
+/** One broad fan blade from the hub, rotated about the hub. */
+const blade = (deg) => {
+    const a = (deg * Math.PI) / 180;
+    const p = (x, y) => `${n(x * Math.cos(a) - y * Math.sin(a) + FAN[0])} ${n(x * Math.sin(a) + y * Math.cos(a) + FAN[1])}`;
+    return `M${p(0, 0)}C${p(-1.75, -0.75)} ${p(-1.55, -BLADE)} ${p(0, -BLADE)}C${p(1.55, -BLADE)} ${p(1.75, -0.75)} ${p(0, 0)}Z`;
+};
+const WELL_SLOT = `M${WELL_X - WELL_HALF} ${GROUND - 0.1}H${WELL_X + WELL_HALF}V${LAYER.top + 1}H${WELL_X - WELL_HALF}Z`;
+export const carbonCaptureArt = {
+    name: 'carbon-capture',
+    parts: [
+        {
+            // O=C=O in the air, drawn below the unit so its intake face swallows it.
+            name: 'co2',
+            paths: [disc(3.8, MOLECULE_Y, 1.2), disc(5.8, MOLECULE_Y, 1.55), disc(7.8, MOLECULE_Y, 1.2)],
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{}, { x: INTAKE }, { x: SWALLOWED, opacity: 0 }],
+            gestures: [
+                null,
+                {
+                    // Pulled in through the fan; the next molecule drifts in from the air.
+                    duration: 3,
+                    repeatAfter: 3.6,
+                    frames: [
+                        { at: 0 },
+                        { at: 0.08 },
+                        { at: 0.36, x: SWALLOWED - INTAKE },
+                        { at: 0.4, x: SWALLOWED - INTAKE, opacity: -1 },
+                        { at: 0.48, x: -5.2, opacity: -1 },
+                        { at: 0.92 },
+                        { at: 1 },
+                    ],
+                },
+                null,
+            ],
+        },
+        {
+            name: 'unit',
+            paths: [
+                `M${UNIT.left} ${GROUND}V${n(UNIT.top + UNIT.r)}A${UNIT.r} ${UNIT.r} 0 0 1 ${n(UNIT.left + UNIT.r)} ${UNIT.top}` +
+                    `H${n(UNIT.right - UNIT.r)}A${UNIT.r} ${UNIT.r} 0 0 1 ${UNIT.right} ${n(UNIT.top + UNIT.r)}V${GROUND}Z`,
+            ],
+            surface: true,
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'fan',
+            paths: [blade(0), blade(120), blade(240)],
+            fillOnly: 'ink',
+            pivot: FAN,
+            spin: { state: 1, degreesPerSecond: 140 },
+            poses: [{}, {}, {}],
+        },
+        {
+            // Solid rock below the ground surface.
+            name: 'rock',
+            paths: [
+                `M2.6 ${GROUND}H21.4V20.2C21.4 20.86 20.86 21.4 20.2 21.4H3.8C3.14 21.4 2.6 20.86 2.6 20.2Z`,
+            ],
+            fillOnly: 'ink',
+            poses: [{}, {}, {}],
+        },
+        {
+            // The injection well and the porous storage layer under the caprock.
+            name: 'reservoir',
+            paths: [WELL_SLOT, layer(LAYER.left)],
+            fillOnly: 'surface',
+            poses: [{}, {}, {}],
+        },
+        {
+            // CO2 spreading through the storage layer from the well.
+            name: 'stored-co2',
+            paths: [layer(LAYER.left)],
+            pathStates: [[layer(EMPTY_LEFT)], [layer(10.6)], [layer(LAYER.left)]],
+            pathOffsets: [RETRACT],
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{ opacity: 0 }, {}, {}],
+            gestures: [
+                {
+                    // Emptied: fade where it is, then shrink back unseen.
+                    duration: 1.6,
+                    repeatAfter: 1.6,
+                    loop: false,
+                    frames: [{ at: 0, flex: -0.5 }, { at: 0.3, flex: -0.5 }, { at: 1 }],
+                },
+                null,
+                {
+                    // The layer fills outward from the well over about two seconds.
+                    duration: 2.4,
+                    repeatAfter: 2.4,
+                    loop: false,
+                    frames: [{ at: 0, flex: HOLD_STORED }, { at: 0.12, flex: HOLD_STORED }, { at: 1 }],
+                },
+            ],
+        },
+        {
+            // Injection under way: captured CO2 runs down the well.
+            name: 'injection',
+            paths: [WELL_SLOT],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: [WELL_X, GROUND],
+            poses: [{ scaleY: 0, opacity: 0 }, {}, { scaleY: 0, opacity: 0 }],
+            gestures: [
+                null,
+                {
+                    duration: 3,
+                    repeatAfter: 3.6,
+                    frames: [
+                        { at: 0 },
+                        { at: 0.3 },
+                        { at: 0.36, opacity: -1 },
+                        { at: 0.4, opacity: -1, scaleY: -1 },
+                        { at: 0.44, scaleY: -1 },
+                        { at: 0.74 },
+                        { at: 1 },
+                    ],
+                },
+                null,
+            ],
+        },
+    ],
+};

package/dist/icons/content-credentials/content-credentials-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type ContentCredentialsState } from "./content-credentials-rig.js";
+export { contentCredentialsStates, type ContentCredentialsState } from "./content-credentials-rig.js";
+export type ContentCredentialsIconProps = StatefulIconProps<ContentCredentialsState>;
+export declare const ContentCredentialsIcon: import("react").NamedExoticComponent<ContentCredentialsIconProps>;

package/dist/icons/content-credentials/content-credentials-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { contentCredentialsArt, contentCredentialsStates, } from "./content-credentials-rig.js";
+export { contentCredentialsStates } from "./content-credentials-rig.js";
+export const ContentCredentialsIcon = memo(function ContentCredentialsIcon(props) {
+    return (_jsx(ArticulatedIcon, { art: contentCredentialsArt, states: contentCredentialsStates, ...props }));
+});