shaders 3.1.462 → 3.2.464

package/dist/core/std/effects/stylize.d.ts

@@ -0,0 +1,177 @@
+import { Expr, GpuFragmentParams, KitTexture } from '../../gpu/contract';
+import { d } from '../../gpu/kit/index';
+import { RttFilterParams } from '../../gpu/scaffolds/rttFilter';
+import { GatherEffect } from '../types';
+import { PropRef } from '../values';
+
+/** One gather stage: a value derived from the child RTT. */
+export type GatherStage = (params: RttFilterParams) => Expr;
+/**
+ * The bleed frame: the tap position with a time-wobbled edge break, shared by the original
+ * sample and every brush tap. `amount` at 0 compiles the wobble away (pair with
+ * `recompile: crosses(0)` on the definition); the wobble is authored in LOGICAL pixels.
+ */
+export declare function bleedWarp(slots: {
+    amount: PropRef;
+}): GatherStage;
+/** The four overlapping Kuwahara quadrants: premultiplied sum + rgb sum² each, plus the tap weight. */
+export type KuwaharaBrush = (params: RttFilterParams) => {
+    quadrants: {
+        sum: Expr;
+        sq: Expr;
+    }[];
+    invN: number;
+};
+/**
+ * The Kuwahara brush: 4 overlapping quadrants of taps around the `at` frame, accumulating
+ * premultiplied sum + rgb sum² per quadrant at the builder level. `radius` is a compile-time
+ * brush size (the tap loop is unrolled in JS, stride-2 taps at texel-pair midpoints so one
+ * bilinear fetch covers a 2×2 block); every tap is hoisted into a local so it samples exactly
+ * once. The footprint is authored in LOGICAL pixels so it stays the same physical size at any
+ * DPR.
+ */
+export declare function kuwahara(slots: {
+    at: GatherStage;
+    radius: PropRef;
+}): KuwaharaBrush;
+/**
+ * The paper-grain stage: screen-space (device-pixel) value noise. `amount` at 0 compiles the
+ * noise away (pair with `recompile: crosses(0)` on the definition).
+ */
+export declare function paperGrain(slots: {
+    amount: PropRef;
+}): GatherStage;
+/**
+ * The wash compose gather recipe: the winning-quadrant Kuwahara mean (lowest variance, mixed
+ * back toward the original by `strength`) over the `at` frame, broken by the paper grain toward
+ * `paperColor`. The gather runs in PREMULTIPLIED space and unpremultiplies once in the compose,
+ * so the result is straight alpha. `strength` at 0 compiles the whole gather away (pair with
+ * `recompile: crosses(0)` on the definition).
+ */
+export declare function wash(slots: {
+    at: GatherStage;
+    brush: KuwaharaBrush;
+    grain: GatherStage;
+    paper: PropRef;
+    paperColor: PropRef;
+    strength: PropRef;
+}): GatherEffect;
+/** The Sobel ring: the two 4-luma bundles around the centre tap, plus the centre sample itself. */
+export type SobelRing = (params: RttFilterParams) => {
+    sobelA: Expr;
+    sobelB: Expr;
+    centre: Expr;
+    centreLum: Expr;
+};
+/**
+ * The Sobel tap ring: 8 straight-alpha tap luminances at `spacing` around the fragment (packed
+ * `[tl, t, tr, l]` / `[r, bl, b, br]`), plus the centre sample and its luminance. Multi-tap → a
+ * true gather, not a uvRemap candidate.
+ */
+export declare function sobelTaps(slots: {
+    spacing: PropRef;
+}): SobelRing;
+/**
+ * The chalk-sketch compose gather recipe: the Sobel edge magnitude from the ring becomes the
+ * stroke outline, cross-hatch line families fill darker regions, and value-noise dust breaks up
+ * the strokes over the board colour. Straight alpha throughout (every tap is unpremultiplied).
+ */
+export declare function chalkSketch(slots: {
+    edges: SobelRing;
+    sensitivity: PropRef;
+    hatchScale: PropRef;
+    shading: PropRef;
+    grain: PropRef;
+    board: PropRef;
+    chalk: PropRef;
+}): GatherEffect;
+/** One custom-tier fragment stage. */
+export type FragmentStage = (params: GpuFragmentParams) => Expr;
+/**
+ * The character grid frame: the cell struct (`cellCenter`, `cellUV`, `isOutside`) shared by the
+ * cell sample, the glyph lookup, and the tint.
+ */
+export declare function charGrid(slots: {
+    cellSize: PropRef;
+    spacing: PropRef;
+}): FragmentStage;
+/** The per-cell child colour: the child sampled once at the cell centre, unpremultiplied. */
+export declare function cellSample(slots: {
+    grid: FragmentStage;
+}): FragmentStage;
+/**
+ * The glyph lookup: the cell brightness (gamma-curved) picks a glyph from the CPU-rasterised
+ * atlas, sampled nearest/clamped at the cell-local UV. Requires the
+ * `_charCount`/`_atlasScale`/`_atlasSize` extraFields on the definition; the `atlas` slot runs
+ * the host raster lifecycle at composition time and returns the glyph texture.
+ */
+export declare function glyphFor(slots: {
+    grid: FragmentStage;
+    cell: FragmentStage;
+    gamma: PropRef;
+    atlas: (params: GpuFragmentParams) => KitTexture;
+}): FragmentStage;
+/**
+ * The glyph tint compose: the glyph shaped by the cell colour, with background / out-of-bounds /
+ * below-threshold pixels turned transparent. Returns the fragment closure for the custom tier's
+ * `gpu.fragment`.
+ */
+export declare function glyphTint(slots: {
+    grid: FragmentStage;
+    cell: FragmentStage;
+    glyph: FragmentStage;
+    alphaThreshold: PropRef;
+    preserveAlpha: PropRef;
+}): FragmentStage;
+/**
+ * Oriented-box placement field: aspect-corrected screen UV → rotated box-local UV + inside mask.
+ * `center` is the TRANSFORMED position prop (transformPosition stores (x, 1-y)), so `1 - center.y`
+ * recovers the authored y. Returns vec3(localU, localV, insideMask); the consumer samples its
+ * content texture at `.xy` and gates by `.z`. No V-flip — media textures written via
+ * `copyExternalImageToTexture` are top-left origin, matching the local V directly.
+ */
+export declare const orientedBoxField: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, center: d.Vec2f, rotationDeg: d.F32, halfW: d.F32, halfH: d.F32) => d.Vec3f>;
+/**
+ * One hatched line plate. Lines run along `angleDeg`; the coordinate perpendicular to them
+ * carries a cosine wave whose crests are inked. `level` (0 = black, 1 = white) slides the ink
+ * threshold across the wave, so darker tone → wider ink until the lines merge to solid;
+ * `reliefPhase` shifts the wave with image brightness — the classic engraved "lines climb over
+ * the form" look. `aa` is the analytic per-pixel wave footprint used for the smoothstep edge.
+ */
+export declare const hatchPlate: import('typegpu').TgpuFn<(p: d.Vec2f, angleDeg: d.F32, frequency: d.F32, reliefPhase: d.F32, level: d.F32, aa: d.F32) => d.F32>;
+/**
+ * The spiral plate: an Archimedean spiral around `c` — rings spaced 1/frequency apart, each
+ * advancing one full spacing per turn, so the line spirals continuously outward from the centre
+ * (the classic guilloché portrait cut). Same tonal threshold + relief displacement as the
+ * straight plate; the angular term's footprint grows toward the centre, so the spiral naturally
+ * tightens into a dense knot there.
+ */
+export declare const spiralPlate: import('typegpu').TgpuFn<(p: d.Vec2f, c: d.Vec2f, frequency: d.F32, reliefPhase: d.F32, level: d.F32, aa: d.F32) => d.F32>;
+/**
+ * The linework composite (factory — `style` is a compile-time JS branch: 0 = single line plate,
+ * 1 = cross-hatch (base + a +72° plate engaging in the shadows + a −38° plate in the deepest
+ * blacks — the classic copper-plate build-up), 2 = one continuous spiral cut around `center`).
+ *
+ * Shared tonal front-end: pivot-0.5 contrast curve on luminance, wavy burin-stroke domain warp,
+ * analytic AA, brightness→phase relief — then the style's plate stack inked between `paper`
+ * and `ink`. p0 = (angleDeg, frequency, relief, waviness); p1 = (contrast, viewportY, 0, 0).
+ */
+export declare function makeLineworkComposite(style: number): import('typegpu').TgpuFn<(childColor: d.Vec4f, uv: d.Vec2f, aspect: d.F32, paper: d.Vec4f, ink: d.Vec4f, center: d.Vec2f, p0: d.Vec4f, p1: d.Vec4f) => d.Vec4f>;
+/**
+ * Line-engraving gather noun: sample the composed child once (unpremultiplied) and redraw it as
+ * luminance-displaced line work between `paper` and `ink`. `style` binds a compile-time prop —
+ * exactly one plate stack is emitted per composition. The composite works on and returns
+ * STRAIGHT alpha, so no unpremultiply tail is appended.
+ */
+export declare function linework(slots: {
+    style: PropRef;
+    frequency: PropRef;
+    angle: PropRef;
+    center: PropRef;
+    relief: PropRef;
+    waviness: PropRef;
+    contrast: PropRef;
+    ink: PropRef;
+    paper: PropRef;
+}): GatherEffect;
+//# sourceMappingURL=stylize.d.ts.map

package/dist/core/std/effects/stylize.d.ts.map

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

package/dist/core/std/filter.d.ts

@@ -0,0 +1,46 @@
+import { Paint } from './paint/fields';
+import { GatherEffect, PointwiseEffect } from './types';
+import { PropRef, ScalarInput } from './values';
+
+/** Mix the child's rgb toward a color by a scalar amount, preserving alpha (linear-RGB). */
+export interface TintTowardEffect {
+    readonly kind: 'tintToward';
+    readonly color: PropRef;
+    readonly amount: ScalarInput;
+}
+export declare function tintToward(color: PropRef, opts: {
+    amount: ScalarInput;
+}): TintTowardEffect;
+/**
+ * Displace the child's sample coordinates by a vector field (a simulation output), with a
+ * chromatic R/B split around the displaced tap and edge handling per tap. A gather effect:
+ * the child renders to a texture, taps are premultiplied, and the result is straight
+ * alpha — the alpha discipline is the species', never the author's.
+ */
+export interface DisplaceByEffect {
+    readonly kind: 'displaceBy';
+    readonly field: import('./sim').SimOutputRef;
+    readonly strength: PropRef;
+    readonly chromatic: PropRef;
+    /** Binds a structural edge-mode prop ('stretch' | 'transparent' | 'mirror' | 'wrap'). */
+    readonly edges: PropRef;
+}
+export declare function displaceBy(field: import('./sim').SimOutputRef, opts: {
+    strength: PropRef;
+    chromatic: PropRef;
+    edges: PropRef;
+}): DisplaceByEffect;
+/** L1 tier: a pointwise filter around a blessed bespoke `'use gpu'` body. */
+export declare function pointwise(config: Omit<PointwiseEffect, 'kind'>): PointwiseEffect;
+/** L1 tier: a gather filter around a blessed bespoke tap chain over the child texture. */
+export declare function gather(config: Omit<GatherEffect, 'kind'>): GatherEffect;
+/**
+ * A paint shown through the child — the CSS `mask-image` of the language, inverted:
+ * the child is the mask, the paint is the content. `by: 'alpha'` (default) reveals the
+ * paint wherever the child has coverage (gradient-through-text); `by: 'luminance'`
+ * reveals it by the child's brightness. The paint's own alpha still applies.
+ */
+export declare function paintThrough(paint: Paint, opts?: {
+    by?: 'alpha' | 'luminance';
+}): PointwiseEffect;
+//# sourceMappingURL=filter.d.ts.map

package/dist/core/std/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/std/filter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAA;AAEzC,OAAO,KAAK,EAAC,YAAY,EAAE,eAAe,EAAC,MAAM,SAAS,CAAA;AAC1D,OAAO,KAAK,EAAC,OAAO,EAAE,WAAW,EAAC,MAAM,UAAU,CAAA;AAElD,4FAA4F;AAC5F,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAC/B;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE;IAAC,MAAM,EAAE,WAAW,CAAA;CAAC,GAAG,gBAAgB,CAExF;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,OAAO,EAAE,YAAY,CAAA;IAC5C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAC1B;AAED,wBAAgB,UAAU,CACtB,KAAK,EAAE,OAAO,OAAO,EAAE,YAAY,EACnC,IAAI,EAAE;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,GAC9D,gBAAgB,CAElB;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,eAAe,CAEhF;AAED,0FAA0F;AAC1F,wBAAgB,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG,YAAY,CAEvE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE;IAAC,EAAE,CAAC,EAAE,OAAO,GAAG,WAAW,CAAA;CAAM,GAAG,eAAe,CAWnG"}

package/dist/core/std/frames.d.ts

@@ -0,0 +1,54 @@
+import { Expr, GpuFragmentParams } from '../gpu/contract';
+import { PropRef } from './values';
+
+/** The generator surface: composed UV, effective viewport, and aspect — locals-bound. */
+export declare function surfaceOf(params: GpuFragmentParams): {
+    uv: Expr;
+    viewport: Expr;
+    aspect: Expr;
+};
+export interface SegmentFrame {
+    /** Distance travelled along the from→to axis (0 at `from`). */
+    along: Expr;
+    /** Signed perpendicular distance from the axis. */
+    across: Expr;
+    /** Length of the from→to segment (≥ 1e-4). */
+    length: Expr;
+}
+/**
+ * An aspect-corrected frame along the segment between two position props: the pixel's
+ * `along`/`across` coordinates plus the segment `length`. Positions are transformPosition
+ * values (stored `(x, 1−y)`).
+ */
+export declare function segmentFrame(slots: {
+    from: PropRef;
+    to: PropRef;
+}): (params: GpuFragmentParams, surface: {
+    uv: Expr;
+    aspect: Expr;
+}) => SegmentFrame;
+/** A degrees prop as a unit vector — `(cos θ, sin θ)`, bound to one local. */
+export declare function direction(angleDeg: Expr | number, hint?: string): Expr;
+export interface DirectionFrame {
+    /** Unit vector along the frame's direction. */
+    tangent: Expr;
+    /** Unit vector perpendicular to it (90° counter-clockwise). */
+    perp: Expr;
+    /** Project a 2D point into the frame: distance along / across the direction. */
+    coordsOf(p: Expr): {
+        along: Expr;
+        across: Expr;
+    };
+}
+/**
+ * A rotated 2D basis from a degrees prop — the frame a directional surface (brush grain, weave,
+ * streaks, flow) lives in. `coordsOf` gives grain-space coordinates; `tangent`/`perp` are the
+ * axes for smearing or tilting along it.
+ */
+export declare function directionFrame(angleDeg: Expr | number, hint?: string): DirectionFrame;
+/**
+ * Fold a point around a centre into one angular sector (mirrored at the sector's half) —
+ * the kaleidoscope domain fold. Returns the folded point in polar-recovered coordinates.
+ */
+export declare function sectorFold(x: Expr, y: Expr, sectorAngle: Expr, center?: number): Expr;
+//# sourceMappingURL=frames.d.ts.map

package/dist/core/std/frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../../src/std/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,UAAU,CAAA;AAOrC,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAC,CAK7F;AAED,MAAM,WAAW,YAAY;IACzB,+DAA+D;IAC/D,KAAK,EAAE,IAAI,CAAA;IACX,mDAAmD;IACnD,MAAM,EAAE,IAAI,CAAA;IACZ,8CAA8C;IAC9C,MAAM,EAAE,IAAI,CAAA;CACf;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAC,YAC5C,iBAAiB,WAAW;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAC,KAAG,YAAY,CAsBtF;AAED,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,EAAE,IAAI,SAAQ,GAAG,IAAI,CAGrE;AAED,MAAM,WAAW,cAAc;IAC3B,+CAA+C;IAC/C,OAAO,EAAE,IAAI,CAAA;IACb,+DAA+D;IAC/D,IAAI,EAAE,IAAI,CAAA;IACV,gFAAgF;IAChF,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG;QAAC,KAAK,EAAE,IAAI,CAAC;QAAC,MAAM,EAAE,IAAI,CAAA;KAAC,CAAA;CACjD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,EAAE,IAAI,SAAU,GAAG,cAAc,CAatF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,SAAM,GAAG,IAAI,CASlF"}

package/dist/core/std/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `@coreroot/std` — the standard authoring layer for shader definitions.
+ *
+ * A shader definition authored on std is declarative data built from these constructors;
+ * `defineStd` lowers it onto the engine scaffolds and kit primitives and returns an
+ * ordinary `GpuShaderDefinition` — registry generation, framework components, editor
+ * metadata and presets are all untouched. GPU math lives in the kit behind the nouns; the
+ * per-species L1 tiers (`pointwise`, `gather`, a warp's map fn, a generator's paint
+ * builder) carry blessed bespoke bodies where the vocabulary does not reach yet.
+ */
+export { defineStd } from './lower';
+export { tintToward, pointwise, gather, displaceBy, paintThrough } from './filter';
+export { radialMask } from './mask';
+export { simulate, op, GridSim } from './sim';
+export { pointer, pointerSpeed } from './signal';
+export { p, Scalar } from './values';
+export { crosses, recompileWhen, isZero, isValue, allOf, identityWhenever } from './slots';
+export { ctx, pointwiseOp, resolveArg, resolveScalar, uniformOf } from './invoke';
+export { d as schema } from '../gpu/kit/index';
+export type { ArgSpec, CtxToken } from './invoke';
+export { lerpToIdentity, selectMap } from '../gpu/scaffolds/uvRemapShader';
+export type { UvMap, UvMapResult, UvMapSource, UvRemapHookParams } from '../gpu/scaffolds/uvRemapShader';
+export type { FilterParams } from '../gpu/scaffolds/pointwiseFilter';
+export type { RttFilterParams } from '../gpu/scaffolds/rttFilter';
+export type { SdfShapeShaderSpec, SdfShapeBounds } from '../gpu/scaffolds/sdfShape';
+export type { StdDefinition, StdDefinitionBase, StdPointwiseFilterDefinition, StdGatherFilterDefinition, StdWarpDefinition, StdShapeDefinition, StdGeneratorDefinition, StdCustomDefinition, StdProps, StdPropConfig, PointwiseEffect, GatherEffect, RecompileRule, IdentityRule, } from './types';
+export type { TintTowardEffect, DisplaceByEffect } from './filter';
+export type { PropRef, ScalarInput, ScalarSource } from './values';
+export type { GridSimConfig, SimOutputRef, GridStepOp, GridDeriveOp } from './sim';
+export type { PointerSignal, PointerSpeedSignal } from './signal';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/std/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/std/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AACjC,OAAO,EAAC,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAC,MAAM,UAAU,CAAA;AAChF,OAAO,EAAC,UAAU,EAAC,MAAM,QAAQ,CAAA;AACjC,OAAO,EAAC,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAC,MAAM,OAAO,CAAA;AAC3C,OAAO,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAC,CAAC,EAAE,MAAM,EAAC,MAAM,UAAU,CAAA;AAClC,OAAO,EAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAC,MAAM,SAAS,CAAA;AACxF,OAAO,EAAC,GAAG,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAC,MAAM,UAAU,CAAA;AAI/E,OAAO,EAAC,CAAC,IAAI,MAAM,EAAC,MAAM,kBAAkB,CAAA;AAC5C,YAAY,EAAC,OAAO,EAAE,QAAQ,EAAC,MAAM,UAAU,CAAA;AAG/C,OAAO,EAAC,cAAc,EAAE,SAAS,EAAC,MAAM,gCAAgC,CAAA;AACxE,YAAY,EAAC,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,iBAAiB,EAAC,MAAM,gCAAgC,CAAA;AACtG,YAAY,EAAC,YAAY,EAAC,MAAM,kCAAkC,CAAA;AAClE,YAAY,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAA;AAC/D,YAAY,EAAC,kBAAkB,EAAE,cAAc,EAAC,MAAM,2BAA2B,CAAA;AAEjF,YAAY,EACR,aAAa,EACb,iBAAiB,EACjB,4BAA4B,EAC5B,yBAAyB,EACzB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,eAAe,EACf,YAAY,EACZ,aAAa,EACb,YAAY,GACf,MAAM,SAAS,CAAA;AAChB,YAAY,EAAC,gBAAgB,EAAE,gBAAgB,EAAC,MAAM,UAAU,CAAA;AAChE,YAAY,EAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAC,MAAM,UAAU,CAAA;AAChE,YAAY,EAAC,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAC,MAAM,OAAO,CAAA;AAChF,YAAY,EAAC,aAAa,EAAE,kBAAkB,EAAC,MAAM,UAAU,CAAA"}

package/dist/core/std/invoke.d.ts

@@ -0,0 +1,45 @@
+import { Expr } from '../gpu/contract';
+import { expr } from '../gpu/composer';
+import { FilterParams } from '../gpu/scaffolds/pointwiseFilter';
+import { PointwiseEffect } from './types';
+import { Scalar, PropRef, ScalarSource, SignalSlotParams } from './values';
+
+/** A read of one of the system context values. Build via {@link ctx}. */
+export interface CtxToken {
+    readonly kind: 'ctx';
+    readonly name: 'uv' | 'aspect' | 'time' | 'viewportSize' | 'logicalViewportSize' | 'pointer';
+}
+/** Context tokens for arg specs: `ctx.uv`, `ctx.aspect`, … */
+export declare const ctx: {
+    readonly uv: CtxToken;
+    readonly aspect: CtxToken;
+    readonly time: CtxToken;
+    readonly viewportSize: CtxToken;
+    readonly logicalViewportSize: CtxToken;
+    readonly pointer: CtxToken;
+};
+/** One declarative GPU-body argument. */
+export type ArgSpec = PropRef | Scalar | CtxToken | number;
+/** The minimal host surface slots resolve against (warp hooks carry no `ctx`). */
+export type SlotParams = SignalSlotParams;
+/** Resolve a prop binding to its uniform accessor (throws on a dangling name). */
+export declare function uniformOf(ref: PropRef, params: {
+    uniforms: Record<string, Expr>;
+}): Expr;
+/** Resolve a scalar value-graph node to an Expr against the composition params. */
+export declare function resolveScalar(input: Scalar | ScalarSource, params: SlotParams): Expr;
+/** Resolve any ArgSpec to an Expr against the composition params. */
+export declare function resolveArg(spec: ArgSpec, params: FilterParams): Expr;
+/** {@link resolveArg} against any slot host (warp hooks included). */
+export declare function resolveArgIn(spec: ArgSpec, params: SlotParams): Expr;
+/** Never-used guard so `expr` stays available to vocabulary modules re-exporting it. */
+export { expr as rawExpr };
+/**
+ * Build a pointwise filter effect from a kit body + declarative arg specs. The child
+ * colour is always the body's first argument; `args` follow in order.
+ */
+export declare function pointwiseOp(fn: unknown, hint: string, args: ArgSpec[], extra?: {
+    compose?: PointwiseEffect['compose'];
+    setup?: PointwiseEffect['setup'];
+}): PointwiseEffect;
+//# sourceMappingURL=invoke.d.ts.map

package/dist/core/std/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../src/std/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAO,IAAI,EAAS,MAAM,iBAAiB,CAAA;AAElD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,kCAAkC,CAAA;AAClE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,SAAS,CAAA;AAC5C,OAAO,EAAC,MAAM,EAAE,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAC,MAAM,UAAU,CAAA;AAEvF,yEAAyE;AACzE,MAAM,WAAW,QAAQ;IACrB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,qBAAqB,GAAG,SAAS,CAAA;CAC/F;AAED,8DAA8D;AAC9D,eAAO,MAAM,GAAG;iBACqB,QAAQ;qBACA,QAAQ;mBACZ,QAAQ;2BACQ,QAAQ;kCACM,QAAQ;sBAChC,QAAQ;CAC7C,CAAA;AAEV,yCAAyC;AACzC,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE1D,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAA;AAEzC,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAAC,GAAG,IAAI,CAItF;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAgBpF;AAED,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAEpE;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAYpE;AAED,wFAAwF;AACxF,OAAO,EAAC,IAAI,IAAI,OAAO,EAAC,CAAA;AAExB;;;GAGG;AACH,wBAAgB,WAAW,CACvB,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EAAE,EACf,KAAK,CAAC,EAAE;IAAC,OAAO,CAAC,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;CAAC,GACjF,eAAe,CAQjB"}

package/dist/core/std/lower.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from '../types';
+import { GpuShaderDefinition } from '../gpu/contract';
+import { StdDefinition } from './types';
+
+/** Lower a std definition to the engine contract. */
+export declare function defineStd<T extends ComponentProps>(definition: StdDefinition<T>): GpuShaderDefinition<T>;
+//# sourceMappingURL=lower.d.ts.map

package/dist/core/std/lower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../../src/std/lower.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAC,cAAc,EAAa,MAAM,UAAU,CAAA;AACxD,OAAO,KAAK,EAA0B,mBAAmB,EAAa,MAAM,iBAAiB,CAAA;AAO7F,OAAO,KAAK,EAGR,aAAa,EAQhB,MAAM,SAAS,CAAA;AAgOhB,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAWxG"}

package/dist/core/std/mask.d.ts

@@ -0,0 +1,12 @@
+import { PropRef, Scalar } from './values';
+
+/**
+ * Aspect-corrected radial falloff: 0 inside `radius`, rising to 1 at `radius + falloff`.
+ * `center` binds a position prop (transformPosition-stored). Body: `fields.radialFalloffMask`.
+ */
+export declare function radialMask(slots: {
+    center: PropRef;
+    radius: PropRef;
+    falloff: PropRef;
+}): Scalar;
+//# sourceMappingURL=mask.d.ts.map

package/dist/core/std/mask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask.d.ts","sourceRoot":"","sources":["../../src/std/mask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,UAAU,CAAA;AACrC,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAE/B;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,GAAG,MAAM,CAE9F"}

package/dist/core/std/math.d.ts

@@ -0,0 +1,52 @@
+import { Expr } from '../gpu/contract';
+
+type Val = Expr | number;
+export declare const add: (a: Val, b: Val) => Expr;
+export declare const sub: (a: Val, b: Val) => Expr;
+export declare const mul: (a: Val, b: Val) => Expr;
+export declare const div: (a: Val, b: Val) => Expr;
+export declare const neg: (a: Val) => Expr;
+export declare const abs: (x: Val) => Expr;
+export declare const floor: (x: Val) => Expr;
+export declare const ceil: (x: Val) => Expr;
+export declare const fract: (x: Val) => Expr;
+export declare const sqrt: (x: Val) => Expr;
+export declare const pow: (x: Val, y: Val) => Expr;
+export declare const exp: (x: Val) => Expr;
+export declare const log: (x: Val) => Expr;
+export declare const sin: (x: Val) => Expr;
+export declare const cos: (x: Val) => Expr;
+export declare const tan: (x: Val) => Expr;
+export declare const atan2: (y: Val, x: Val) => Expr;
+export declare const min: (a: Val, b: Val) => Expr;
+export declare const max: (a: Val, b: Val) => Expr;
+export declare const clamp: (x: Val, lo: Val, hi: Val) => Expr;
+export declare const mix: (a: Val, b: Val, t: Val) => Expr;
+export declare const step: (edge: Val, x: Val) => Expr;
+export declare const smoothstep: (e0: Val, e1: Val, x: Val) => Expr;
+export declare const sign: (x: Val) => Expr;
+export declare const length: (v: Val) => Expr;
+export declare const distance: (a: Val, b: Val) => Expr;
+export declare const dot: (a: Val, b: Val) => Expr;
+export declare const normalize: (v: Val) => Expr;
+export declare const cross: (a: Val, b: Val) => Expr;
+export declare const lt: (a: Val, b: Val) => Expr;
+export declare const le: (a: Val, b: Val) => Expr;
+export declare const gt: (a: Val, b: Val) => Expr;
+export declare const ge: (a: Val, b: Val) => Expr;
+/** `cond ? ifTrue : ifFalse` (WGSL `select` takes false-value first — handled here). */
+export declare const select: (cond: Expr, ifTrue: Val, ifFalse: Val) => Expr;
+export declare const float: (n: number) => Expr;
+export declare const vec2: (x: Val, y: Val) => Expr;
+export declare const vec3: (x: Val, y: Val, z: Val) => Expr;
+export declare const vec4: (...parts: Val[]) => Expr;
+/** Broadcast a scalar into a vec3 (the common vector-mix third argument). */
+export declare const splat3: (x: Val) => Expr;
+/** Bind an expression to one WGSL local so every consumer reads the same evaluation. */
+export declare const local: (e: Expr, hint: string) => Expr;
+/** Smooth relu: 0 below zero, →x above, blended over `k` — the standard soft elbow. */
+export declare const softPlus: (x: Expr, k: Val) => Expr;
+/** Gaussian bell over a normalized coordinate: `exp(−k·x²)`. */
+export declare const gaussBell: (x: Expr, k: Val) => Expr;
+export {};
+//# sourceMappingURL=math.d.ts.map

package/dist/core/std/math.d.ts.map

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

package/dist/core/std/motion.d.ts

@@ -0,0 +1,53 @@
+import { Expr } from '../gpu/contract';
+import { Scalar } from './values';
+
+/** Position within a repeating cycle, 0..1 (`fract(t / period)`). */
+export declare function phase(t: Expr, period: Expr | number): Expr;
+/**
+ * A repeating cycle: `progress` (0..1 within the cycle) and `index` (which cycle this
+ * is) — the "every N seconds" word. Feed `index` to {@link cycleSeed} for something
+ * random-but-stable per pass (a meteor's angle, a glitch's offset).
+ */
+export declare function cycle(t: Expr, period: Expr | number): {
+    progress: Expr;
+    index: Expr;
+};
+/** A random-but-stable 0..1 value per cycle index (change `salt` for independent draws). */
+export declare function cycleSeed(index: Expr, salt?: number): Expr;
+/**
+ * An on/off rhythm: 1 for the first `duty` fraction of each cycle, 0 for the rest.
+ * `soften` (cycle-fraction units) eases both edges; 0 is a hard blink.
+ */
+export declare function pulseTrain(t: Expr, opts: {
+    period: Expr | number;
+    duty: Expr | number;
+    soften?: number;
+}): Expr;
+/** A sine sweep between `min` and `max` at `rate` cycles per second. */
+export declare function oscillate(t: Expr, opts: {
+    rate?: number;
+    min?: Expr | number;
+    max?: Expr | number;
+    offset?: number;
+}): Expr;
+export declare const easeIn: (x: Expr) => Expr;
+export declare const easeOut: (x: Expr) => Expr;
+export declare const easeInOut: (x: Expr) => Expr;
+type SignalClock = 'global' | 'node';
+/** {@link oscillate} as a slot signal. */
+export declare function oscillating(opts: {
+    rate?: number;
+    min?: Expr | number;
+    max?: Expr | number;
+    offset?: number;
+    clock?: SignalClock;
+}): Scalar;
+/** {@link pulseTrain} as a slot signal. */
+export declare function pulsing(opts: {
+    period: number;
+    duty: number;
+    soften?: number;
+    clock?: SignalClock;
+}): Scalar;
+export {};
+//# sourceMappingURL=motion.d.ts.map

package/dist/core/std/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/std/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AAGzC,OAAO,EAAC,MAAM,EAAwB,MAAM,UAAU,CAAA;AAItD,qEAAqE;AACrE,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,GAAG;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAC,CAGnF;AAED,4FAA4F;AAC5F,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,SAAI,GAAG,IAAI,CAErD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;IAAC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAO7G;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAKzH;AAID,eAAO,MAAM,MAAM,MAAO,IAAI,KAAG,IAAiB,CAAA;AAClD,eAAO,MAAM,OAAO,MAAO,IAAI,KAAG,IAAyC,CAAA;AAC3E,eAAO,MAAM,SAAS,MAAO,IAAI,KAAG,IAA2B,CAAA;AAI/D,KAAK,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAA;AAQpC,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAAC,GAAG,MAAM,CAEzI;AAED,2CAA2C;AAC3C,wBAAgB,OAAO,CAAC,IAAI,EAAE;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAAC,GAAG,MAAM,CAE1G"}

package/dist/core/std/paint/compose.d.ts

@@ -0,0 +1,14 @@
+import { Expr } from '../../gpu/contract';
+
+export type Layer = Expr | {
+    paint: Expr;
+    /** 'add' (default) sums light; 'screen' folds it in with 1−(1−a)(1−b). */
+    blend?: 'add' | 'screen';
+    /** Scales the layer's contribution. */
+    opacity?: Expr | number;
+    /** A transmittance the layer is seen through (content behind a medium). */
+    behind?: Expr;
+};
+/** Composite a stack of paint contributions, first entry at the back. */
+export declare function layers(entries: Layer[]): Expr;
+//# sourceMappingURL=compose.d.ts.map

package/dist/core/std/paint/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/std/paint/compose.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAA;AAG5C,MAAM,MAAM,KAAK,GACX,IAAI,GACJ;IACE,KAAK,EAAE,IAAI,CAAA;IACX,0EAA0E;IAC1E,KAAK,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAA;IACxB,uCAAuC;IACvC,OAAO,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;IACvB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,IAAI,CAAA;CAChB,CAAA;AAEL,yEAAyE;AACzE,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAe7C"}