semiotic 3.7.5 → 3.8.0

package/dist/components/stream/physics/PhysicsAccessibility.d.ts

@@ -0,0 +1,48 @@
+import type { NavTreeNode } from "../../ai/navigationTree";
+import type { PhysicsBodyState } from "./PhysicsKernel";
+import type { PhysicsObservationEvent } from "./PhysicsPipelineStore";
+export interface PhysicsProjectionContainerSpec {
+    id: string;
+    label: string;
+    count?: number;
+    secondary?: number;
+    secondaryLabel?: string;
+    observed?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface PhysicsProjectionBodySummary {
+    id: string;
+    label: string;
+    datum?: unknown;
+}
+export interface PhysicsSettledProjectionRow {
+    id: string;
+    label: string;
+    count: number;
+    share: number;
+    secondary?: number;
+    secondaryLabel?: string;
+    observed?: number;
+    bodyIds: string[];
+    recentBodies: PhysicsProjectionBodySummary[];
+    metadata?: Record<string, unknown>;
+}
+export interface PhysicsSettledProjectionOptions {
+    bodies?: PhysicsBodyState[];
+    getContainerId?: (body: PhysicsBodyState) => string | undefined;
+    getBodyLabel?: (body: PhysicsBodyState) => string | undefined;
+    recentBodyLimit?: number;
+}
+export interface PhysicsNavigationTreeOptions {
+    chartId?: string;
+    chartType?: string;
+    title?: string;
+    projectionLabel?: string;
+    maxBodiesPerContainer?: number;
+}
+export interface PhysicsObservationAnnouncementOptions {
+    getDatumLabel?: (datum: unknown, event: PhysicsObservationEvent) => string | undefined;
+}
+export declare function buildPhysicsSettledProjection(containers: PhysicsProjectionContainerSpec[], options?: PhysicsSettledProjectionOptions): PhysicsSettledProjectionRow[];
+export declare function buildPhysicsNavigationTree(rows: PhysicsSettledProjectionRow[], options?: PhysicsNavigationTreeOptions): NavTreeNode;
+export declare function physicsObservationAnnouncement(event: PhysicsObservationEvent, options?: PhysicsObservationAnnouncementOptions): string | null;

package/dist/components/stream/physics/PhysicsAnnotations.d.ts

@@ -0,0 +1,58 @@
+import type { PhysicsBodyState, PhysicsColliderSpec } from "./PhysicsKernel";
+import type { PhysicsPlotBounds } from "./PhysicsPipelineStore";
+export type PhysicsAnnotationRole = "barrier" | "sensor";
+export type PhysicsAnnotationAxis = "x" | "y";
+export interface PhysicsStaticAnnotation {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    x1?: number;
+    x2?: number;
+    y1?: number;
+    y2?: number;
+    dx?: number;
+    dy?: number;
+    physics?: PhysicsAnnotationRole;
+    axis?: PhysicsAnnotationAxis;
+    colliderId?: string;
+    thickness?: number;
+    restitution?: number;
+    friction?: number;
+    description?: string;
+}
+export interface PhysicsBodyAnnotation {
+    id: string;
+    label: string;
+    bodyId: string;
+    dx?: number;
+    dy?: number;
+    description?: string;
+}
+export interface PhysicsResolvedBodyAnnotation extends PhysicsBodyAnnotation {
+    anchorX: number;
+    anchorY: number;
+    labelX: number;
+    labelY: number;
+    body: PhysicsBodyState;
+}
+export interface PhysicsAnnotationSummary {
+    bodyCount: number;
+    barrierCount: number;
+    sensorCount: number;
+    staticCount: number;
+    totalCount: number;
+}
+export interface PhysicsAnnotationColliderOptions {
+    idPrefix?: string;
+    plotBounds?: PhysicsPlotBounds;
+    defaultAxis?: PhysicsAnnotationAxis;
+    barrierThickness?: number;
+    sensorThickness?: number;
+    thickness?: number;
+    barrierRestitution?: number;
+    barrierFriction?: number;
+}
+export declare function collidersFromPhysicsAnnotations(annotations?: PhysicsStaticAnnotation[], options?: PhysicsAnnotationColliderOptions): PhysicsColliderSpec[];
+export declare function resolvePhysicsBodyAnnotations(annotations: PhysicsBodyAnnotation[], bodies: PhysicsBodyState[]): PhysicsResolvedBodyAnnotation[];
+export declare function summarizePhysicsAnnotations(staticAnnotations?: PhysicsStaticAnnotation[], bodyAnnotations?: PhysicsBodyAnnotation[]): PhysicsAnnotationSummary;

package/dist/components/stream/physics/PhysicsBodyBudget.d.ts

@@ -0,0 +1,26 @@
+export type PhysicsBodyBudgetState = "ok" | "warning" | "overflow";
+export type PhysicsBodyBudgetAction = "continue" | "evict" | "retain" | "sediment";
+export interface PhysicsBodyBudgetOptions {
+    warnAt?: number;
+}
+export interface PhysicsBodyBudgetInput {
+    bodyLimit?: number;
+    engineMaxBodiesHint?: number;
+    evictionEnabled?: boolean;
+    liveBodies: number;
+    queuedBodies?: number;
+    sedimentEnabled?: boolean;
+    options?: false | PhysicsBodyBudgetOptions;
+}
+export interface PhysicsBodyBudgetDecision {
+    action: PhysicsBodyBudgetAction;
+    bodyLimit?: number;
+    engineMaxBodiesHint?: number;
+    liveBodies: number;
+    overflow: number;
+    projectedBodies: number;
+    queuedBodies: number;
+    state: PhysicsBodyBudgetState;
+    warnAt?: number;
+}
+export declare function evaluatePhysicsBodyBudget(input: PhysicsBodyBudgetInput): PhysicsBodyBudgetDecision;

package/dist/components/stream/physics/PhysicsBodySpatialIndex.d.ts

@@ -0,0 +1,10 @@
+import type { PhysicsEngineAdapter } from "./PhysicsEngineAdapter";
+import type { PhysicsBodyState } from "./PhysicsKernel";
+/** Revision-keyed body index used by PhysicsPipelineStore hit testing. */
+export declare class PhysicsBodySpatialIndex {
+    private maxSearchRadius;
+    private revision;
+    private tree;
+    hitTest(world: PhysicsEngineAdapter, revision: number, liveBodyOrder: readonly string[], x: number, y: number, radius?: number): PhysicsBodyState | null;
+    private ensure;
+}

package/dist/components/stream/physics/PhysicsCanvasTheme.d.ts

@@ -0,0 +1,26 @@
+export interface PhysicsCanvasTheme {
+    annotationBackground: string;
+    annotationStroke: string;
+    annotationText: string;
+    background: string;
+    border: string;
+    closedWindowFill: string;
+    closedWindowStroke: string;
+    danger: string;
+    focus: string;
+    grid: string;
+    gutterFill: string;
+    lateFill: string;
+    openWindowFill: string;
+    openWindowStroke: string;
+    primary: string;
+    selectedFill: string;
+    selectedStroke: string;
+    success: string;
+    text: string;
+    textSecondary: string;
+    warning: string;
+}
+export declare const DEFAULT_PHYSICS_CANVAS_THEME: PhysicsCanvasTheme;
+export declare function physicsCanvasColorWithAlpha(color: string, opacity: number): string;
+export declare function resolvePhysicsCanvasTheme(ctx: CanvasRenderingContext2D): PhysicsCanvasTheme;

package/dist/components/stream/physics/PhysicsControllers.d.ts

@@ -0,0 +1,75 @@
+/** Stateful process rules that ride StreamPhysicsFrame's live heartbeat. */
+import type { PhysicsBodyState } from "./PhysicsKernel";
+import type { PhysicsPipelineControlSurface, PhysicsPipelineTickResult } from "./PhysicsPipelineStore";
+import type { StreamPhysicsBodyForce, StreamPhysicsBodyForceContext, StreamPhysicsBodyRegionState, StreamPhysicsRegionVector } from "./StreamPhysicsFrame";
+import { createCapacityQueueController } from "./CapacityQueueController";
+export { createCapacityQueueController };
+export type { CapacityQueueAbandonedInfo, CapacityQueueAgeSummary, CapacityQueueBlockedInfo, CapacityQueueControllerOptions, CapacityQueueProcessedInfo, CapacityQueueSnapshot, CapacityQueueVisitInfo, CapacityQueueWindowSnapshot } from "./CapacityQueueTypes";
+export interface PhysicsControllerTickContext {
+    result: PhysicsPipelineTickResult;
+    controls: PhysicsPipelineControlSurface;
+    /**
+     * Exact simulated seconds advanced by the kernel for this callback:
+     * `result.steps * fixedDt`. This is zero when a pipeline tick does not run a
+     * fixed substep, so time-based controller work must not advance on that tick.
+     */
+    dt: number;
+    elapsed: number;
+    /**
+     * Region membership for a body (active region ids, charges, attributes).
+     * Backed by StreamPhysicsFrame region state.
+     */
+    getRegionState: (bodyId: string) => StreamPhysicsBodyRegionState | undefined;
+}
+export interface PhysicsController {
+    /** Stable id for debugging / observation. */
+    id: string;
+    /**
+     * Keep the RAF loop alive even when the kernel reports allSleeping.
+     * Capacity queues and continuous process rules should set this true.
+     */
+    continuous?: boolean;
+    /**
+     * Called after each store tick and continuous-force application. It may run
+     * with `context.dt === 0` when the frame only synchronizes runtime state.
+     */
+    tick: (context: PhysicsControllerTickContext) => void;
+    /**
+     * Optional force contribution composed into StreamPhysicsFrame bodyForces.
+     * The frame integrates the returned vector over simulated fixed-step time
+     * and applies no impulse when the tick advances zero substeps. Return null to
+     * skip this body.
+     */
+    bodyForce?: (context: StreamPhysicsBodyForceContext) => StreamPhysicsRegionVector | null | undefined;
+    /** Optional live metrics for settled projection / readouts. */
+    getSnapshot?: () => unknown;
+    dispose?: () => void;
+}
+export interface ComposedPhysicsControllers {
+    controllers: PhysicsController[];
+    continuous: boolean;
+    onTick: (result: PhysicsPipelineTickResult, controls: PhysicsPipelineControlSurface, extras: {
+        dt: number;
+        elapsed: number;
+        getRegionState: PhysicsControllerTickContext["getRegionState"];
+    }) => void;
+    bodyForce: StreamPhysicsBodyForce;
+}
+/**
+ * Compose controllers into a single continuous flag, bodyForce, and onTick.
+ * Call onTick from StreamPhysicsFrame after each pipeline tick; `ctx.dt`
+ * accounts for every fixed substep completed by that tick.
+ */
+export declare function composePhysicsControllers(controllers: readonly PhysicsController[] | undefined | null): ComposedPhysicsControllers | null;
+/** Apply one portal impulse per active-region visit. */
+export declare function createPortalController(options: {
+    id?: string;
+    fromRegionId: string;
+    impulse?: StreamPhysicsRegionVector;
+    continuous?: boolean;
+    onPortal?: (body: PhysicsBodyState) => void;
+}): PhysicsController;
+export type PhysicsControllerFactory = typeof createCapacityQueueController;
+export { createDependencyGateController, createServiceLevelController, createServiceResourcePoolController } from "./ServiceOperationsControllers";
+export type { DependencyGateController, ServiceLevelController, ServiceResourcePoolController } from "./ServiceOperationsControllers";
+export type { DependencyGateOptions, DependencyGateSnapshot, ServiceLevelCaseInfo, ServiceLevelCaseState, ServiceLevelControllerOptions, ServiceLevelSnapshot, ServiceResourceAssignment, ServiceResourceDefinition, ServiceResourcePoolOptions, ServiceResourcePoolSnapshot } from "./ServiceOperationsTypes";

package/dist/components/stream/physics/PhysicsEngineAdapter.d.ts

@@ -0,0 +1,59 @@
+import { type PhysicsActiveSensorPair, type PhysicsBodySpec, type PhysicsBodyState, type PhysicsColliderSpec, type PhysicsKernelEvent, type PhysicsKernelOptions, type PhysicsKernelSnapshot, type PhysicsSpringSpec } from "./PhysicsKernel";
+export type PhysicsEngineDeterminism = "strict" | "tolerance" | "none";
+export interface PhysicsEngineCapabilities {
+    engine: string;
+    determinism: PhysicsEngineDeterminism;
+    sensors: boolean;
+    joints: boolean;
+    ccd: boolean;
+    maxBodiesHint: number;
+    worker: boolean;
+}
+export interface PhysicsEngineAdapter {
+    readonly id: string;
+    readonly capabilities: PhysicsEngineCapabilities;
+    init: (options?: PhysicsKernelOptions) => void;
+    spawn: (spec: PhysicsBodySpec) => void;
+    remove: (ids: string[]) => void;
+    setColliders: (colliders: PhysicsColliderSpec[]) => void;
+    setConstraint: (spec: PhysicsSpringSpec) => string;
+    removeConstraint: (id: string) => void;
+    applyImpulse: (id: string, ix: number, iy: number) => void;
+    step: (dtSeconds?: number) => void;
+    settle: (maxSteps?: number, dtSeconds?: number) => number;
+    readState: (out?: PhysicsBodyState[]) => PhysicsBodyState[];
+    events: () => PhysicsKernelEvent[];
+    activeSensorPairs: () => PhysicsActiveSensorPair[];
+    allSleeping: () => boolean;
+    snapshot: () => PhysicsKernelSnapshot;
+    restore: (snapshot: PhysicsKernelSnapshot) => void;
+    nextRandom: () => number;
+    dispose: () => void;
+}
+export type PhysicsEngineAdapterFactory = (options?: PhysicsKernelOptions) => PhysicsEngineAdapter;
+export type PhysicsEngineAdapterInput = PhysicsEngineAdapter | PhysicsEngineAdapterFactory;
+export declare class BuiltInPhysicsEngineAdapter implements PhysicsEngineAdapter {
+    readonly id = "builtin";
+    readonly capabilities: PhysicsEngineCapabilities;
+    private world;
+    constructor(options?: PhysicsKernelOptions);
+    init(options?: PhysicsKernelOptions): void;
+    spawn(spec: PhysicsBodySpec): void;
+    remove(ids: string[]): void;
+    setColliders(colliders: PhysicsColliderSpec[]): void;
+    setConstraint(spec: PhysicsSpringSpec): string;
+    removeConstraint(id: string): void;
+    applyImpulse(id: string, ix: number, iy: number): void;
+    step(dtSeconds?: number): void;
+    settle(maxSteps?: number, dtSeconds?: number): number;
+    readState(out?: PhysicsBodyState[]): PhysicsBodyState[];
+    events(): PhysicsKernelEvent[];
+    activeSensorPairs(): PhysicsActiveSensorPair[];
+    allSleeping(): boolean;
+    snapshot(): PhysicsKernelSnapshot;
+    restore(snapshot: PhysicsKernelSnapshot): void;
+    nextRandom(): number;
+    dispose(): void;
+}
+export declare function createDefaultPhysicsEngineAdapter(options?: PhysicsKernelOptions): PhysicsEngineAdapter;
+export declare function resolvePhysicsEngineAdapter(input: PhysicsEngineAdapterInput | undefined, options?: PhysicsKernelOptions): PhysicsEngineAdapter;

package/dist/components/stream/physics/PhysicsEngineConformance.d.ts

@@ -0,0 +1,23 @@
+import type { PhysicsEngineAdapterFactory, PhysicsEngineDeterminism } from "./PhysicsEngineAdapter";
+export interface PhysicsEngineConformanceOptions {
+    determinism?: PhysicsEngineDeterminism;
+    tolerance?: number;
+}
+export interface PhysicsEngineConformanceBody {
+    id: string;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    sleeping: boolean;
+}
+export interface PhysicsEngineConformanceResult {
+    deterministicReplay: PhysicsEngineConformanceBody[];
+    sensorEvents: string[];
+    sensorFinalX: number;
+    sleepWakeEvents: string[];
+    snapshotReplay: PhysicsEngineConformanceBody[];
+    springBodyX: number;
+}
+export declare function runPhysicsEngineConformance(factory: PhysicsEngineAdapterFactory, _options?: PhysicsEngineConformanceOptions): PhysicsEngineConformanceResult;
+export declare function comparePhysicsEngineConformance(actual: PhysicsEngineConformanceResult, expected: PhysicsEngineConformanceResult, options?: PhysicsEngineConformanceOptions): string[];

package/dist/components/stream/physics/PhysicsEvidence.d.ts

@@ -0,0 +1,25 @@
+import type { PhysicsSettledProjectionRow } from "./PhysicsAccessibility";
+import type { PhysicsBodyState } from "./PhysicsKernel";
+import type { PhysicsPipelineSnapshot } from "./PhysicsPipelineStore";
+export interface PhysicsEvidenceBinCount {
+    id: string;
+    label: string;
+    count: number;
+    secondary?: number;
+    secondaryLabel?: string;
+    observed?: number;
+}
+export interface PhysicsSettledEvidence {
+    bodyCount: number;
+    sleepingCount: number;
+    settled: boolean;
+    stepsRun: number;
+    seed: number;
+    binCounts: PhysicsEvidenceBinCount[];
+}
+export interface PhysicsSettledEvidenceOptions {
+    bodies?: PhysicsBodyState[];
+    projectionRows?: PhysicsSettledProjectionRow[];
+    stepsRun?: number;
+}
+export declare function buildPhysicsSettledEvidence(snapshot: PhysicsPipelineSnapshot, options?: PhysicsSettledEvidenceOptions): PhysicsSettledEvidence;

package/dist/components/stream/physics/PhysicsKernel.d.ts

@@ -0,0 +1,207 @@
+export type PhysicsBodyShape = {
+    type: "circle";
+    radius: number;
+} | {
+    type: "aabb";
+    width: number;
+    height: number;
+};
+export type PhysicsColliderShape = {
+    type: "aabb";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    type: "segment";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    thickness?: number;
+};
+export interface PhysicsKernelOptions {
+    seed?: number;
+    gravity?: {
+        x: number;
+        y: number;
+    };
+    fixedDt?: number;
+    cellSize?: number;
+    collisionIterations?: number;
+    velocityDamping?: number;
+    sleepSpeed?: number;
+    sleepAfter?: number;
+    restitution?: number;
+    friction?: number;
+    /** Speed cap (px/s) applied each substep to prevent tunneling through thin walls. */
+    maxVelocity?: number;
+    /**
+     * Contact impact speed (px/s) above which a resting/sleeping body is woken.
+     * Higher than `sleepSpeed` so a settled pile is not churned by every arrival —
+     * a sleeping body acts as a static anchor until something hits it hard enough.
+     */
+    contactWakeSpeed?: number;
+}
+export interface PhysicsBodySpec {
+    id: string;
+    x: number;
+    y: number;
+    vx?: number;
+    vy?: number;
+    angle?: number;
+    mass?: number;
+    restitution?: number;
+    friction?: number;
+    /** Disable body-body contacts for visual/tethered satellite marks. */
+    bodyCollisions?: boolean;
+    shape: PhysicsBodyShape;
+    datum?: unknown;
+}
+export interface PhysicsBodyState {
+    id: string;
+    x: number;
+    y: number;
+    prevX: number;
+    prevY: number;
+    vx: number;
+    vy: number;
+    angle: number;
+    mass: number;
+    bodyCollisions?: boolean;
+    shape: PhysicsBodyShape;
+    sleeping: boolean;
+    datum?: unknown;
+}
+export interface PhysicsColliderBodyFilterSpec {
+    property: string;
+    equals?: unknown;
+    notEquals?: unknown;
+    oneOf?: unknown[];
+    notOneOf?: unknown[];
+}
+export type PhysicsColliderBodyFilter = PhysicsColliderBodyFilterSpec | ((body: PhysicsBodyState) => boolean);
+export interface PhysicsColliderSpec {
+    id: string;
+    shape: PhysicsColliderShape;
+    sensor?: boolean;
+    restitution?: number;
+    friction?: number;
+    /**
+     * Optional body filter for permeable colliders. Bodies that do not match the
+     * filter ignore this collider or sensor entirely. Object filters are worker
+     * serializable; function filters require sync execution.
+     */
+    bodyFilter?: PhysicsColliderBodyFilter;
+}
+export interface PhysicsSpringSpec {
+    id?: string;
+    bodyId: string;
+    target: {
+        type: "point";
+        x: number;
+        y: number;
+    } | {
+        type: "body";
+        bodyId: string;
+    };
+    restLength?: number;
+    stiffness?: number;
+    damping?: number;
+}
+export interface PhysicsKernelSnapshotBody extends PhysicsBodyState {
+    bodyCollisions: boolean;
+    index: number;
+    sleepTime: number;
+    restitution?: number;
+    friction?: number;
+}
+export interface PhysicsKernelSnapshotCollider extends PhysicsColliderSpec {
+    index: number;
+}
+export interface PhysicsKernelSnapshotSpring extends Required<Omit<PhysicsSpringSpec, "target">> {
+    target: PhysicsSpringSpec["target"];
+}
+export type PhysicsKernelEvent = {
+    type: "contact";
+    bodyId: string;
+    otherId: string;
+    sensor: false;
+} | {
+    type: "sensor-enter";
+    bodyId: string;
+    sensorId: string;
+} | {
+    type: "sensor-exit";
+    bodyId: string;
+    sensorId: string;
+} | {
+    type: "sleep";
+    bodyId: string;
+} | {
+    type: "wake";
+    bodyId: string;
+};
+export interface PhysicsActiveSensorPair {
+    sensorId: string;
+    bodyId: string;
+}
+export interface PhysicsKernelSnapshot {
+    options: Required<PhysicsKernelOptions>;
+    bodies: PhysicsKernelSnapshotBody[];
+    colliders: PhysicsKernelSnapshotCollider[];
+    springs: PhysicsKernelSnapshotSpring[];
+    activeSensors: string[];
+}
+export declare class PhysicsKernelWorld {
+    readonly capabilities: {
+        determinism: "strict";
+        sensors: boolean;
+        joints: boolean;
+        ccd: boolean;
+        maxBodiesHint: number;
+        worker: boolean;
+    };
+    private options;
+    private bodies;
+    private colliders;
+    private springs;
+    private activeSensors;
+    private supportedThisStep;
+    private lastEvents;
+    private nextBodyIndex;
+    private nextColliderIndex;
+    private nextSpringIndex;
+    private random;
+    constructor(options?: PhysicsKernelOptions);
+    init(options?: PhysicsKernelOptions): void;
+    spawn(spec: PhysicsBodySpec): void;
+    remove(ids: string[]): void;
+    setColliders(colliders: PhysicsColliderSpec[]): void;
+    setConstraint(spec: PhysicsSpringSpec): string;
+    removeConstraint(id: string): void;
+    applyImpulse(id: string, ix: number, iy: number): void;
+    step(dtSeconds?: number): void;
+    settle(maxSteps?: number, dtSeconds?: number): number;
+    readState(out?: PhysicsBodyState[]): PhysicsBodyState[];
+    events(): PhysicsKernelEvent[];
+    activeSensorPairs(): PhysicsActiveSensorPair[];
+    allSleeping(): boolean;
+    snapshot(): PhysicsKernelSnapshot;
+    restore(snapshot: PhysicsKernelSnapshot): void;
+    dispose(): void;
+    private sortedBodies;
+    private sortedColliders;
+    private applySprings;
+    private resolveBodyPairs;
+    private bodyPairKeys;
+    private resolveDynamicCollision;
+    private applyFriction;
+    private resolveColliders;
+    private resolveStaticCollision;
+    private updateSensors;
+    private updateSleeping;
+    private wake;
+    /** Uses the deterministic PRNG for future jittered spawn helpers. */
+    nextRandom(): number;
+}

package/dist/components/stream/physics/PhysicsOptionalEngineAdapters.d.ts

@@ -0,0 +1,12 @@
+export interface PhysicsOptionalEngineInstallDetails {
+    engine: string;
+    importPath: string;
+    packageName: string;
+    installCommand: string;
+}
+export declare class PhysicsOptionalEngineDependencyError extends Error {
+    readonly details: PhysicsOptionalEngineInstallDetails;
+    constructor(details: PhysicsOptionalEngineInstallDetails, cause?: unknown);
+}
+export declare function optionalEngineDependencyError(details: PhysicsOptionalEngineInstallDetails, cause?: unknown): PhysicsOptionalEngineDependencyError;
+export declare function loadOptionalPhysicsPeer(details: PhysicsOptionalEngineInstallDetails): Promise<unknown>;

package/dist/components/stream/physics/PhysicsPipelineStore.d.ts

@@ -0,0 +1,84 @@
+import { type PhysicsBodyState, type PhysicsColliderSpec, type PhysicsKernelEvent, type PhysicsSpringSpec } from "./PhysicsKernel";
+import { type PhysicsSedimentBinSnapshot, type PhysicsSedimentColumn, type PhysicsSedimentHeightfieldOptions, type PhysicsSedimentTotals } from "./PhysicsSediment";
+import { type PhysicsBodyBudgetDecision } from "./PhysicsBodyBudget";
+import type { PhysicsObservationEvent, PhysicsObservationRecord, PhysicsPipelineConfig, PhysicsPipelineControlSurface, PhysicsPipelineSnapshot, PhysicsPipelineTickResult, PhysicsQueuedSpawn, PhysicsSpawnPacingOptions } from "./PhysicsPipelineTypes";
+import { type UpdateResult } from "../pipelineUpdateContract";
+export type { PhysicsPlotBounds, PhysicsBoundsColliderOptions, PhysicsXBinColliderOptions, PhysicsSpawnSpringSpec, PhysicsQueuedSpawn, PhysicsSpawnPacing, PhysicsSpawnTimeAccessor, PhysicsSpawnPacingOptions, PhysicsPipelineQueuedSpawnSnapshot, PhysicsObservationEventType, PhysicsSimulationState, PhysicsObservationEvent, PhysicsObservationRecord, PhysicsSensorObservationConfig, PhysicsPipelineObservationOptions, PhysicsPipelineConfig, PhysicsPipelineTickResult, PhysicsPipelineSnapshot, PhysicsPipelineControlSurface } from "./PhysicsPipelineTypes";
+export { schedulePhysicsSpawns, collidersFromPlotBounds, collidersFromXScaleBins } from "./physicsPipelineHelpers";
+export type { ChangeSet, Invalidation, RevisionSet, UpdateResult } from "../pipelineUpdateContract";
+export declare class PhysicsPipelineStore {
+    private activeSensorPairs;
+    private accumulator;
+    private bodyBudget;
+    private bodyBudgetObservationKey;
+    private config;
+    /** Raw public config references, used only for no-op classification. */
+    private configInput;
+    private engineInput?;
+    private bodySpatialIndex;
+    private elapsedSeconds;
+    private liveBodyOrder;
+    private nextSequence;
+    private observation;
+    private paused;
+    private queue;
+    private revision;
+    private updateResults;
+    private sediment;
+    private simulationState;
+    private visible;
+    private world;
+    constructor(config?: PhysicsPipelineConfig);
+    updateConfig(config: PhysicsPipelineConfig): void;
+    /** Additive explicit-result form of {@link updateConfig}. */
+    updateConfigWithResult(config: PhysicsPipelineConfig): UpdateResult;
+    setColliders(colliders: PhysicsColliderSpec[]): void;
+    enqueue(spawn: PhysicsQueuedSpawn | PhysicsQueuedSpawn[], pacing?: PhysicsSpawnPacingOptions): void;
+    /** Additive explicit-result form of {@link enqueue}. */
+    enqueueWithResult(spawn: PhysicsQueuedSpawn | PhysicsQueuedSpawn[], pacing?: PhysicsSpawnPacingOptions): UpdateResult;
+    spawnNow(spawn: PhysicsQueuedSpawn): void;
+    clear(): void;
+    tick(deltaSeconds: number): PhysicsPipelineTickResult;
+    settle(maxSteps?: number): number;
+    settleWithObservations(maxSteps?: number): PhysicsPipelineTickResult;
+    readBodies(out?: PhysicsBodyState[]): PhysicsBodyState[];
+    readSediment(): PhysicsSedimentBinSnapshot[];
+    bodyBudgetStatus(): PhysicsBodyBudgetDecision;
+    sedimentTotals(): PhysicsSedimentTotals;
+    sedimentHeightfield(options?: PhysicsSedimentHeightfieldOptions): PhysicsSedimentColumn[];
+    hitTest(x: number, y: number, radius?: number): PhysicsBodyState | null;
+    events(): PhysicsKernelEvent[];
+    allSleeping(): boolean;
+    hasPendingWork(): boolean;
+    queueSize(): number;
+    liveBodyCount(): number;
+    elapsed(): number;
+    recordObservation(record: PhysicsObservationRecord): PhysicsObservationEvent;
+    /** Most recent explicit update result for a revision-aware host or tool. */
+    getLastUpdateResult(): UpdateResult;
+    version(): number;
+    setPaused(paused: boolean): void;
+    setVisible(visible: boolean): void;
+    remove(ids: string[]): string[];
+    setConstraint(spec: PhysicsSpringSpec): string;
+    removeConstraint(id: string): void;
+    applyImpulse(id: string, ix: number, iy: number): void;
+    nextRandom(): number;
+    controls(): PhysicsPipelineControlSurface;
+    snapshot(): PhysicsPipelineSnapshot;
+    restore(snapshot: PhysicsPipelineSnapshot): void;
+    private spawnDue;
+    private spawnOne;
+    private result;
+    private observeKernelEvents;
+    private observeSensorTransitions;
+    private removeActiveSensorPairsForBodies;
+    private observationContext;
+    private emitObservation;
+    private evaluateBodyBudget;
+    private observeBodyBudget;
+    private syncSimulationState;
+    private evictOverflow;
+    private absorbSediment;
+    private sleepingFirstEvictionOrder;
+}