semiotic 3.7.5 → 3.8.1

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

@@ -0,0 +1,134 @@
+import type { PhysicsBodyState, PhysicsColliderBodyFilter } from "./PhysicsKernel";
+import type { StreamPhysicsRegionVector } from "./StreamPhysicsFrame";
+/** Current age distribution for visits admitted to a capacity queue. */
+export interface CapacityQueueAgeSummary {
+    count: number;
+    meanSeconds: number;
+    p50Seconds: number;
+    p95Seconds: number;
+    oldestSeconds: number;
+}
+/** Rolling simulated-time service evidence. */
+export interface CapacityQueueWindowSnapshot {
+    seconds: number;
+    arrivals: number;
+    arrivalWork: number;
+    completions: number;
+    completedWork: number;
+    processedWork: number;
+    arrivalsPerSecond: number;
+    throughputPerSecond: number;
+    /** Service work consumed / available work capacity, clamped to 0-1. */
+    utilization: number;
+    /** Incoming work rate / service rate. Values above 1 indicate overload. */
+    pressure: number;
+}
+/** Live capacity queue metrics for projection, evidence, and UI. */
+export interface CapacityQueueSnapshot {
+    regionId: string;
+    queueDepth: number;
+    processedCount: number;
+    unitsPerSecond: number;
+    /** Remaining work units currently in the admitted queue. */
+    remainingWork: number;
+    meanRemainingWork: number;
+    /** Current admitted + blocked work still waiting for service. */
+    waitingWork: number;
+    blockedDepth: number;
+    blockedWork: number;
+    /** Unique physical entries observed, including entries initially blocked. */
+    arrivalCount: number;
+    admittedCount: number;
+    admittedWork: number;
+    /** Cumulative service work consumed, including partially processed jobs. */
+    processedWork: number;
+    completedWork: number;
+    blockedCount: number;
+    abandonedCount: number;
+    abandonedWork: number;
+    peakQueueDepth: number;
+    peakRemainingWork: number;
+    queueAge: CapacityQueueAgeSummary;
+    meanCompletedQueueSeconds: number;
+    window: CapacityQueueWindowSnapshot;
+    /** Latest simulated clock observed by the controller. */
+    simulatedAt: number;
+    /** Coarse reporting bucket suitable for React equality checks. */
+    metricRevision: number;
+}
+export interface CapacityQueueVisitInfo {
+    bodyId: string;
+    jobId: string;
+    visitId: string;
+    visit: number;
+    regionId: string;
+    work: number;
+    queuedAt: number;
+}
+export interface CapacityQueueProcessedInfo extends CapacityQueueVisitInfo {
+    completedAt: number;
+    queueSeconds: number;
+}
+export interface CapacityQueueBlockedInfo extends CapacityQueueVisitInfo {
+    blockedAt: number;
+}
+export interface CapacityQueueAbandonedInfo extends CapacityQueueVisitInfo {
+    abandonedAt: number;
+    remainingWork: number;
+    queueSeconds: number;
+}
+export interface CapacityQueueControllerOptions {
+    id?: string;
+    /** Must match a StreamPhysicsRegionEffect id (sensor region). */
+    regionId: string;
+    /** Work units processed per second while the queue is non-empty. */
+    unitsPerSecond: number;
+    /** Only matching bodies may enter the queue. Uses collider body-filter semantics. */
+    bodyFilter?: PhysicsColliderBodyFilter;
+    /** String form reads `body.datum[field]`; defaults to work/reviewWork/value. */
+    unitAccessor?: string | ((body: PhysicsBodyState) => number);
+    /**
+     * Semantic job identity. String form reads `body.datum[field]`; defaults to
+     * body id. Multiple matching bodies with the same key consume one visit.
+     */
+    jobKey?: string | ((body: PhysicsBodyState) => string | number | null | undefined);
+    /** Impulse applied when a body finishes processing (default forward release). */
+    releaseImpulse?: StreamPhysicsRegionVector;
+    onProcessed?: (body: PhysicsBodyState, info: CapacityQueueProcessedInfo) => void;
+    onQueued?: (body: PhysicsBodyState, info: CapacityQueueVisitInfo) => void;
+    onBlocked?: (body: PhysicsBodyState, info: CapacityQueueBlockedInfo) => void;
+    onAbandoned?: (body: PhysicsBodyState, info: CapacityQueueAbandonedInfo) => void;
+    queueLayout?: "lane" | "none";
+    queueSlotSpacing?: number;
+    queueStiffness?: number;
+    /** Max admitted visits; overflow is measured while it waits outside. */
+    maxQueue?: number;
+    /** Rolling simulated-time window for throughput/utilization (default 30s). */
+    metricWindowSeconds?: number;
+    /** Coarse snapshot cadence used by HOC callbacks (default 0.25s). */
+    snapshotIntervalSeconds?: number;
+    continuous?: boolean;
+}
+export interface CapacityQueueEntry {
+    bodyId: string;
+    jobId: string;
+    visitId: string;
+    visit: number;
+    remaining: number;
+    total: number;
+    queuedAt: number;
+    sequence: number;
+}
+export interface CapacityBlockedEntry extends CapacityQueueVisitInfo {
+    blockedAt: number;
+    sequence: number;
+}
+export interface CapacityMetricSlice {
+    start: number;
+    end: number;
+    arrivals: number;
+    arrivalWork: number;
+    completions: number;
+    completedWork: number;
+    processedWork: number;
+}

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

@@ -0,0 +1,42 @@
+import type { PhysicsEngineCapabilities } from "./PhysicsEngineAdapter";
+import type { PhysicsBodySpec, PhysicsColliderSpec } from "./PhysicsKernel";
+export declare const MATTER_PHYSICS_PACKAGE = "matter-js";
+export declare const MATTER_PHYSICS_IMPORT_PATH = "semiotic/physics/matter";
+export declare const MATTER_PHYSICS_CAPABILITIES: PhysicsEngineCapabilities;
+export declare const MATTER_PHYSICS_INSTALL: {
+    readonly engine: "Matter.js";
+    readonly importPath: "semiotic/physics/matter";
+    readonly packageName: "matter-js";
+    readonly installCommand: "npm install matter-js";
+};
+export interface MatterVectorLike {
+    x: number;
+    y: number;
+}
+export interface MatterBoundsLike {
+    min: MatterVectorLike;
+    max: MatterVectorLike;
+}
+export interface MatterBodyLike {
+    id?: string | number;
+    label?: string;
+    position?: MatterVectorLike;
+    velocity?: MatterVectorLike;
+    angle?: number;
+    mass?: number;
+    circleRadius?: number;
+    bounds?: MatterBoundsLike;
+    isSensor?: boolean;
+    plugin?: Record<string, unknown>;
+}
+export interface MatterMigrationOptions {
+    datumFromPlugin?: string;
+    fallbackRadius?: number;
+    idPrefix?: string;
+}
+export declare function matterBodyToPhysicsBodySpec(body: MatterBodyLike, index?: number, options?: MatterMigrationOptions): PhysicsBodySpec;
+export declare function matterBodyToPhysicsColliderSpec(body: MatterBodyLike, index?: number, options?: MatterMigrationOptions): PhysicsColliderSpec;
+export declare function matterBodiesToPhysicsSpawns(bodies: readonly MatterBodyLike[], options?: MatterMigrationOptions): PhysicsBodySpec[];
+export declare function matterBodiesToPhysicsColliders(bodies: readonly MatterBodyLike[], options?: MatterMigrationOptions): PhysicsColliderSpec[];
+export declare function loadMatterPhysicsPeer(): Promise<unknown>;
+export declare function matterPhysicsDependencyError(cause?: unknown): Error;

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;