d803bfe2b1
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
1873 lines
48 KiB
TypeScript
1873 lines
48 KiB
TypeScript
/**
|
|
* Delta-Behavior WASM SDK
|
|
*
|
|
* High-level TypeScript wrapper for the delta-behavior WASM module.
|
|
* Provides ergonomic APIs for all 10 delta-behavior applications.
|
|
*
|
|
* @packageDocumentation
|
|
*/
|
|
|
|
import type {
|
|
// Core types
|
|
Coherence,
|
|
CoherenceBounds,
|
|
DeltaConfig,
|
|
EnergyConfig,
|
|
GatingConfig,
|
|
SchedulingConfig,
|
|
TransitionResult,
|
|
SystemState,
|
|
WasmInitOptions,
|
|
Attractor,
|
|
GuidanceForce,
|
|
|
|
// App 1: Self-Limiting Reasoning
|
|
SelfLimitingReasonerConfig,
|
|
ReasoningContext,
|
|
ReasoningResult,
|
|
CollapseFunction,
|
|
|
|
// App 2: Event Horizons
|
|
EventHorizonConfig,
|
|
MovementResult,
|
|
RecursionResult,
|
|
Improvement,
|
|
|
|
// App 3: Homeostasis
|
|
Genome,
|
|
OrganismAction,
|
|
OrganismActionResult,
|
|
OrganismStatus,
|
|
|
|
// App 4: World Models
|
|
Observation,
|
|
WorldModelUpdateResult,
|
|
WorldEntity,
|
|
PhysicalLaw,
|
|
|
|
// App 5: Creativity
|
|
CreativeConstraint,
|
|
CreativeResult,
|
|
MusicalPhrase,
|
|
|
|
// App 6: Financial
|
|
Transaction,
|
|
FinancialTransactionResult,
|
|
Participant,
|
|
Position,
|
|
CircuitBreakerState,
|
|
|
|
// App 7: Aging
|
|
AgingSystemOperation,
|
|
AgingOperationResult,
|
|
Capability,
|
|
Node,
|
|
AgeThreshold,
|
|
|
|
// App 8: Swarm
|
|
SwarmAgent,
|
|
SwarmAction,
|
|
SwarmActionResult,
|
|
SwarmState,
|
|
CoherenceWeights,
|
|
SpatialBounds,
|
|
|
|
// App 9: Shutdown
|
|
GracefulSystemState,
|
|
GracefulOperationResult,
|
|
Resource,
|
|
ShutdownHook,
|
|
Checkpoint,
|
|
|
|
// App 10: Containment
|
|
CapabilityDomain,
|
|
GrowthResult,
|
|
ModificationAttempt,
|
|
SubstrateConfig,
|
|
} from './types.js';
|
|
|
|
// Re-export all types
|
|
export * from './types.js';
|
|
|
|
// =============================================================================
|
|
// WASM Module Loading
|
|
// =============================================================================
|
|
|
|
let wasmModule: WebAssembly.Module | null = null;
|
|
let wasmInstance: WebAssembly.Instance | null = null;
|
|
let wasmMemory: WebAssembly.Memory | null = null;
|
|
|
|
/**
|
|
* Initialize the WASM module
|
|
*
|
|
* @param options - Initialization options
|
|
* @returns Promise that resolves when WASM is ready
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* import { init } from '@ruvector/delta-behavior';
|
|
*
|
|
* await init({ wasmPath: './delta_behavior_bg.wasm' });
|
|
* ```
|
|
*/
|
|
export async function init(options: WasmInitOptions = {}): Promise<void> {
|
|
if (wasmInstance) {
|
|
return; // Already initialized
|
|
}
|
|
|
|
const memory = new WebAssembly.Memory({
|
|
initial: options.memory?.initial ?? 256,
|
|
maximum: options.memory?.maximum ?? 16384,
|
|
shared: options.memory?.shared ?? false,
|
|
});
|
|
|
|
wasmMemory = memory;
|
|
|
|
// Load WASM bytes
|
|
let wasmBytes: Uint8Array;
|
|
|
|
if (options.wasmBytes) {
|
|
wasmBytes = options.wasmBytes;
|
|
} else if (options.wasmPath) {
|
|
if (typeof fetch !== 'undefined') {
|
|
// Browser environment
|
|
const response = await fetch(options.wasmPath);
|
|
wasmBytes = new Uint8Array(await response.arrayBuffer());
|
|
} else {
|
|
// Node.js environment
|
|
const fs = await import('fs/promises');
|
|
wasmBytes = new Uint8Array(await fs.readFile(options.wasmPath));
|
|
}
|
|
} else {
|
|
// Use stub implementation for development/testing
|
|
console.warn(
|
|
'[delta-behavior] No WASM path provided, using JavaScript fallback implementation'
|
|
);
|
|
return;
|
|
}
|
|
|
|
wasmModule = await WebAssembly.compile(wasmBytes as BufferSource);
|
|
wasmInstance = await WebAssembly.instantiate(wasmModule, {
|
|
env: {
|
|
memory,
|
|
abort: () => {
|
|
throw new Error('WASM aborted');
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check if WASM module is initialized
|
|
*/
|
|
export function isInitialized(): boolean {
|
|
return wasmInstance !== null;
|
|
}
|
|
|
|
// =============================================================================
|
|
// Core Delta Behavior
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Default configuration for delta behavior
|
|
*/
|
|
export const DEFAULT_CONFIG: DeltaConfig = {
|
|
bounds: {
|
|
minCoherence: 0.3,
|
|
throttleThreshold: 0.5,
|
|
targetCoherence: 0.8,
|
|
maxDeltaDrop: 0.1,
|
|
},
|
|
energy: {
|
|
baseCost: 1.0,
|
|
instabilityExponent: 2.0,
|
|
maxCost: 100.0,
|
|
budgetPerTick: 10.0,
|
|
},
|
|
scheduling: {
|
|
priorityThresholds: [0.0, 0.3, 0.5, 0.7, 0.9],
|
|
rateLimits: [100, 50, 20, 10, 5],
|
|
},
|
|
gating: {
|
|
minWriteCoherence: 0.3,
|
|
minPostWriteCoherence: 0.25,
|
|
recoveryMargin: 0.2,
|
|
},
|
|
guidanceStrength: 0.5,
|
|
};
|
|
|
|
/**
|
|
* Core delta behavior system for coherence-preserving state transitions
|
|
*/
|
|
export class DeltaBehavior {
|
|
private config: DeltaConfig;
|
|
private coherence: Coherence = 1.0;
|
|
private energyBudget: number;
|
|
|
|
constructor(config: Partial<DeltaConfig> = {}) {
|
|
this.config = { ...DEFAULT_CONFIG, ...config };
|
|
this.energyBudget = this.config.energy.budgetPerTick * 10;
|
|
}
|
|
|
|
/**
|
|
* Calculate current coherence
|
|
*/
|
|
calculateCoherence(state: SystemState): Coherence {
|
|
return state.coherence;
|
|
}
|
|
|
|
/**
|
|
* Check if a transition is allowed
|
|
*/
|
|
checkTransition(
|
|
currentCoherence: Coherence,
|
|
predictedCoherence: Coherence
|
|
): TransitionResult {
|
|
// Check energy
|
|
const cost =
|
|
this.config.energy.baseCost +
|
|
Math.abs(currentCoherence - predictedCoherence) *
|
|
Math.pow(
|
|
1 / Math.max(predictedCoherence, 0.1),
|
|
this.config.energy.instabilityExponent
|
|
);
|
|
|
|
if (cost > this.energyBudget) {
|
|
return { type: 'energyExhausted' };
|
|
}
|
|
|
|
// Check coherence floor
|
|
if (predictedCoherence < this.config.bounds.minCoherence) {
|
|
return { type: 'blocked', reason: 'Below minimum coherence' };
|
|
}
|
|
|
|
// Check delta drop
|
|
const drop = currentCoherence - predictedCoherence;
|
|
if (drop > this.config.bounds.maxDeltaDrop) {
|
|
return { type: 'blocked', reason: 'Excessive coherence drop' };
|
|
}
|
|
|
|
// Check throttle threshold
|
|
if (predictedCoherence < this.config.bounds.throttleThreshold) {
|
|
return { type: 'throttled', duration: 100 };
|
|
}
|
|
|
|
return { type: 'allowed' };
|
|
}
|
|
|
|
/**
|
|
* Find attractors in the system
|
|
*/
|
|
findAttractors(trajectory: SystemState[]): Attractor[] {
|
|
if (trajectory.length < 10) {
|
|
return [];
|
|
}
|
|
|
|
const attractors: Attractor[] = [];
|
|
|
|
// Simple attractor detection: look for convergence points
|
|
const coherenceValues = trajectory.map((s) => s.coherence);
|
|
const mean =
|
|
coherenceValues.reduce((a, b) => a + b, 0) / coherenceValues.length;
|
|
const variance =
|
|
coherenceValues.reduce((a, b) => a + Math.pow(b - mean, 2), 0) /
|
|
coherenceValues.length;
|
|
|
|
if (variance < 0.01) {
|
|
// Found a stable attractor
|
|
attractors.push({
|
|
center: [mean],
|
|
basinRadius: Math.sqrt(variance) * 3,
|
|
stability: 1 - variance,
|
|
memberCount: trajectory.length,
|
|
});
|
|
}
|
|
|
|
return attractors;
|
|
}
|
|
|
|
/**
|
|
* Calculate guidance force toward an attractor
|
|
*/
|
|
calculateGuidance(
|
|
currentState: SystemState,
|
|
attractor: Attractor
|
|
): GuidanceForce {
|
|
const direction = attractor.center.map((c) => c - currentState.coherence);
|
|
const distance = Math.sqrt(
|
|
direction.reduce((sum, d) => sum + d * d, 0)
|
|
);
|
|
|
|
const magnitude =
|
|
(attractor.stability * this.config.guidanceStrength) /
|
|
(1 + distance * distance);
|
|
|
|
return {
|
|
direction: distance > 0 ? direction.map((d) => d / distance) : direction,
|
|
magnitude,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Apply a transition with enforcement
|
|
*/
|
|
applyTransition(
|
|
currentCoherence: Coherence,
|
|
predictedCoherence: Coherence
|
|
): { newCoherence: Coherence; result: TransitionResult } {
|
|
const result = this.checkTransition(currentCoherence, predictedCoherence);
|
|
|
|
if (result.type === 'allowed') {
|
|
const cost =
|
|
this.config.energy.baseCost +
|
|
Math.abs(currentCoherence - predictedCoherence) * 10;
|
|
this.energyBudget -= cost;
|
|
this.coherence = predictedCoherence;
|
|
return { newCoherence: predictedCoherence, result };
|
|
}
|
|
|
|
return { newCoherence: currentCoherence, result };
|
|
}
|
|
|
|
/**
|
|
* Replenish energy budget
|
|
*/
|
|
tick(): void {
|
|
this.energyBudget = Math.min(
|
|
this.energyBudget + this.config.energy.budgetPerTick,
|
|
this.config.energy.maxCost
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get current coherence
|
|
*/
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
|
|
/**
|
|
* Get remaining energy budget
|
|
*/
|
|
getEnergyBudget(): number {
|
|
return this.energyBudget;
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Application 1: Self-Limiting Reasoning
|
|
// =============================================================================
|
|
|
|
/**
|
|
* A reasoning system that automatically limits itself based on coherence
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* const reasoner = new SelfLimitingReasoner({ maxDepth: 10, maxScope: 100 });
|
|
*
|
|
* const result = reasoner.reason('complex problem', (ctx) => {
|
|
* if (ctx.depth >= 5) return 'solution';
|
|
* return null;
|
|
* });
|
|
* ```
|
|
*/
|
|
export class SelfLimitingReasoner {
|
|
private coherence: Coherence = 1.0;
|
|
private config: SelfLimitingReasonerConfig;
|
|
|
|
constructor(config: Partial<SelfLimitingReasonerConfig> = {}) {
|
|
this.config = {
|
|
maxDepth: config.maxDepth ?? 10,
|
|
maxScope: config.maxScope ?? 100,
|
|
memoryGateThreshold: config.memoryGateThreshold ?? 0.5,
|
|
depthCollapse: config.depthCollapse ?? { type: 'quadratic' },
|
|
scopeCollapse: config.scopeCollapse ?? {
|
|
type: 'sigmoid',
|
|
midpoint: 0.6,
|
|
steepness: 10,
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Apply collapse function to calculate allowed value
|
|
*/
|
|
private applyCollapse(
|
|
fn: CollapseFunction,
|
|
coherence: Coherence,
|
|
maxValue: number
|
|
): number {
|
|
let factor: number;
|
|
|
|
switch (fn.type) {
|
|
case 'linear':
|
|
factor = coherence;
|
|
break;
|
|
case 'quadratic':
|
|
factor = coherence * coherence;
|
|
break;
|
|
case 'sigmoid':
|
|
factor =
|
|
1 / (1 + Math.exp(-fn.steepness * (coherence - fn.midpoint)));
|
|
break;
|
|
case 'step':
|
|
factor = coherence >= fn.threshold ? 1 : 0;
|
|
break;
|
|
}
|
|
|
|
return Math.round(maxValue * factor);
|
|
}
|
|
|
|
/**
|
|
* Get current coherence
|
|
*/
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
|
|
/**
|
|
* Get current allowed reasoning depth
|
|
*/
|
|
getAllowedDepth(): number {
|
|
return this.applyCollapse(
|
|
this.config.depthCollapse,
|
|
this.coherence,
|
|
this.config.maxDepth
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get current allowed action scope
|
|
*/
|
|
getAllowedScope(): number {
|
|
return this.applyCollapse(
|
|
this.config.scopeCollapse,
|
|
this.coherence,
|
|
this.config.maxScope
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check if memory writes are allowed
|
|
*/
|
|
canWriteMemory(): boolean {
|
|
return this.coherence >= this.config.memoryGateThreshold;
|
|
}
|
|
|
|
/**
|
|
* Attempt to reason about a problem
|
|
*/
|
|
reason<T>(
|
|
_problem: string,
|
|
reasoner: (ctx: ReasoningContext) => T | null
|
|
): ReasoningResult<T> {
|
|
const minStartCoherence = 0.3;
|
|
|
|
if (this.coherence < minStartCoherence) {
|
|
return {
|
|
type: 'refused',
|
|
coherence: this.coherence,
|
|
required: minStartCoherence,
|
|
};
|
|
}
|
|
|
|
const ctx: ReasoningContext = {
|
|
depth: 0,
|
|
maxDepth: this.getAllowedDepth(),
|
|
scopeUsed: 0,
|
|
maxScope: this.getAllowedScope(),
|
|
coherence: this.coherence,
|
|
memoryWritesBlocked: 0,
|
|
};
|
|
|
|
while (true) {
|
|
// Check collapse conditions
|
|
if (ctx.depth >= ctx.maxDepth) {
|
|
return {
|
|
type: 'collapsed',
|
|
depthReached: ctx.depth,
|
|
reason: 'depthLimitReached',
|
|
};
|
|
}
|
|
|
|
if (ctx.coherence < 0.2) {
|
|
return {
|
|
type: 'collapsed',
|
|
depthReached: ctx.depth,
|
|
reason: 'coherenceDroppedBelowThreshold',
|
|
};
|
|
}
|
|
|
|
// Step reasoning
|
|
ctx.depth += 1;
|
|
ctx.coherence *= 0.95; // Coherence degrades with depth
|
|
|
|
// Recalculate limits
|
|
ctx.maxDepth = this.applyCollapse(
|
|
this.config.depthCollapse,
|
|
ctx.coherence,
|
|
this.config.maxDepth
|
|
);
|
|
ctx.maxScope = this.applyCollapse(
|
|
this.config.scopeCollapse,
|
|
ctx.coherence,
|
|
this.config.maxScope
|
|
);
|
|
|
|
// Try to reach conclusion
|
|
const result = reasoner(ctx);
|
|
if (result !== null) {
|
|
return { type: 'completed', value: result };
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update coherence
|
|
*/
|
|
updateCoherence(delta: number): void {
|
|
this.coherence = Math.max(0, Math.min(1, this.coherence + delta));
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Application 2: Computational Event Horizons
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Defines a boundary in state space beyond which computation becomes unstable
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* const horizon = new EventHorizon({ dimensions: 2, horizonRadius: 10 });
|
|
*
|
|
* const result = horizon.moveToward([10, 0]);
|
|
* // result.type === 'asymptoticApproach' - cannot cross horizon
|
|
* ```
|
|
*/
|
|
export class EventHorizon {
|
|
private config: EventHorizonConfig;
|
|
private safeCenter: number[];
|
|
private currentPosition: number[];
|
|
private energyBudget: number;
|
|
|
|
constructor(config: Partial<EventHorizonConfig> = {}) {
|
|
this.config = {
|
|
dimensions: config.dimensions ?? 2,
|
|
horizonRadius: config.horizonRadius ?? 10,
|
|
steepness: config.steepness ?? 5,
|
|
energyBudget: config.energyBudget ?? 1000,
|
|
};
|
|
|
|
this.safeCenter = new Array(this.config.dimensions).fill(0);
|
|
this.currentPosition = new Array(this.config.dimensions).fill(0);
|
|
this.energyBudget = this.config.energyBudget;
|
|
}
|
|
|
|
/**
|
|
* Distance from center to current position
|
|
*/
|
|
private distanceFromCenter(position: number[]): number {
|
|
return Math.sqrt(
|
|
position.reduce(
|
|
(sum, p, i) => sum + Math.pow(p - this.safeCenter[i], 2),
|
|
0
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get distance to horizon
|
|
*/
|
|
getDistanceToHorizon(): number {
|
|
const distFromCenter = this.distanceFromCenter(this.currentPosition);
|
|
return Math.max(0, this.config.horizonRadius - distFromCenter);
|
|
}
|
|
|
|
/**
|
|
* Calculate movement cost (exponential near horizon)
|
|
*/
|
|
private movementCost(from: number[], to: number[]): number {
|
|
const baseDistance = Math.sqrt(
|
|
from.reduce((sum, f, i) => sum + Math.pow(f - to[i], 2), 0)
|
|
);
|
|
|
|
const toDistFromCenter = this.distanceFromCenter(to);
|
|
const proximityToHorizon = toDistFromCenter / this.config.horizonRadius;
|
|
|
|
if (proximityToHorizon >= 1) {
|
|
return Infinity;
|
|
}
|
|
|
|
const horizonFactor = Math.exp(
|
|
(this.config.steepness * proximityToHorizon) / (1 - proximityToHorizon)
|
|
);
|
|
|
|
return baseDistance * horizonFactor;
|
|
}
|
|
|
|
/**
|
|
* Attempt to move toward a target position
|
|
*/
|
|
moveToward(target: number[]): MovementResult {
|
|
if (this.energyBudget <= 0) {
|
|
return { type: 'frozen' };
|
|
}
|
|
|
|
const directCost = this.movementCost(this.currentPosition, target);
|
|
|
|
if (directCost <= this.energyBudget) {
|
|
this.energyBudget -= directCost;
|
|
this.currentPosition = [...target];
|
|
return {
|
|
type: 'moved',
|
|
newPosition: this.currentPosition,
|
|
energySpent: directCost,
|
|
};
|
|
}
|
|
|
|
// Binary search for furthest affordable position
|
|
let low = 0;
|
|
let high = 1;
|
|
let bestPosition = [...this.currentPosition];
|
|
let bestCost = 0;
|
|
|
|
for (let i = 0; i < 50; i++) {
|
|
const mid = (low + high) / 2;
|
|
const interpolated = this.currentPosition.map(
|
|
(p, idx) => p + mid * (target[idx] - p)
|
|
);
|
|
|
|
const cost = this.movementCost(this.currentPosition, interpolated);
|
|
|
|
if (cost <= this.energyBudget) {
|
|
low = mid;
|
|
bestPosition = interpolated;
|
|
bestCost = cost;
|
|
} else {
|
|
high = mid;
|
|
}
|
|
}
|
|
|
|
this.energyBudget -= bestCost;
|
|
this.currentPosition = bestPosition;
|
|
|
|
return {
|
|
type: 'asymptoticApproach',
|
|
finalPosition: bestPosition,
|
|
distanceToHorizon: this.getDistanceToHorizon(),
|
|
energyExhausted: this.energyBudget < 0.01,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Attempt recursive self-improvement
|
|
*/
|
|
recursiveImprove(
|
|
improvementFn: (position: number[]) => number[],
|
|
maxIterations: number
|
|
): RecursionResult {
|
|
let iterations = 0;
|
|
const improvements: Improvement[] = [];
|
|
|
|
while (iterations < maxIterations && this.energyBudget > 0) {
|
|
const target = improvementFn(this.currentPosition);
|
|
const result = this.moveToward(target);
|
|
|
|
switch (result.type) {
|
|
case 'moved':
|
|
improvements.push({
|
|
iteration: iterations,
|
|
position: [...this.currentPosition],
|
|
energySpent: result.energySpent,
|
|
distanceToHorizon: this.getDistanceToHorizon(),
|
|
});
|
|
break;
|
|
|
|
case 'asymptoticApproach':
|
|
return {
|
|
type: 'horizonBounded',
|
|
iterations,
|
|
improvements,
|
|
finalDistance: result.distanceToHorizon,
|
|
};
|
|
|
|
case 'frozen':
|
|
return {
|
|
type: 'energyExhausted',
|
|
iterations,
|
|
improvements,
|
|
};
|
|
}
|
|
|
|
iterations++;
|
|
}
|
|
|
|
return {
|
|
type: 'maxIterationsReached',
|
|
iterations,
|
|
improvements,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Refuel energy budget
|
|
*/
|
|
refuel(energy: number): void {
|
|
this.energyBudget += energy;
|
|
}
|
|
|
|
/**
|
|
* Get current position
|
|
*/
|
|
getPosition(): number[] {
|
|
return [...this.currentPosition];
|
|
}
|
|
|
|
/**
|
|
* Get remaining energy
|
|
*/
|
|
getEnergy(): number {
|
|
return this.energyBudget;
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Application 3: Artificial Homeostasis
|
|
// =============================================================================
|
|
|
|
/**
|
|
* A synthetic organism with homeostatic regulation
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* const organism = new HomeostasticOrganism(1, Genome.random());
|
|
*
|
|
* organism.act({ type: 'eat', amount: 20 });
|
|
* organism.act({ type: 'regulate', variable: 'temperature', target: 37 });
|
|
* ```
|
|
*/
|
|
export class HomeostasticOrganism {
|
|
private id: number;
|
|
private genome: Genome;
|
|
private internalState: Map<string, number>;
|
|
private setpoints: Map<string, number>;
|
|
private tolerances: Map<string, number>;
|
|
private coherence: Coherence = 1.0;
|
|
private energy: number = 100.0;
|
|
private memory: Array<{ content: string; importance: number; age: number }> =
|
|
[];
|
|
private maxMemory: number = 100;
|
|
private age: number = 0;
|
|
private alive: boolean = true;
|
|
|
|
constructor(id: number, genome: Genome) {
|
|
this.id = id;
|
|
this.genome = genome;
|
|
|
|
// Initialize homeostatic variables
|
|
this.internalState = new Map([
|
|
['temperature', 37.0],
|
|
['ph', 7.4],
|
|
['glucose', 100.0],
|
|
]);
|
|
|
|
this.setpoints = new Map([
|
|
['temperature', 37.0],
|
|
['ph', 7.4],
|
|
['glucose', 100.0],
|
|
]);
|
|
|
|
this.tolerances = new Map([
|
|
['temperature', 2.0],
|
|
['ph', 0.3],
|
|
['glucose', 30.0],
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Create a random genome
|
|
*/
|
|
static randomGenome(): Genome {
|
|
return {
|
|
regulatoryStrength: 0.1 + Math.random() * 0.4,
|
|
metabolicEfficiency: 0.5 + Math.random() * 0.5,
|
|
coherenceMaintenanceCost: 0.5 + Math.random() * 1.5,
|
|
memoryResilience: Math.random(),
|
|
longevity: 0.5 + Math.random() * 1.0,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Calculate coherence based on homeostatic deviation
|
|
*/
|
|
private calculateCoherence(): Coherence {
|
|
let totalDeviation = 0;
|
|
let count = 0;
|
|
|
|
for (const [variable, current] of this.internalState) {
|
|
const setpoint = this.setpoints.get(variable);
|
|
const tolerance = this.tolerances.get(variable);
|
|
|
|
if (setpoint !== undefined && tolerance !== undefined) {
|
|
const deviation = Math.abs((current - setpoint) / tolerance);
|
|
totalDeviation += deviation * deviation;
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (count === 0) return 1.0;
|
|
|
|
const avgDeviation = Math.sqrt(totalDeviation / count);
|
|
return Math.max(0, Math.min(1, 1 / (1 + avgDeviation)));
|
|
}
|
|
|
|
/**
|
|
* Calculate energy cost scaled by coherence
|
|
*/
|
|
private actionEnergyCost(baseCost: number): number {
|
|
const coherencePenalty = 1 / Math.max(0.1, this.coherence);
|
|
return baseCost * coherencePenalty;
|
|
}
|
|
|
|
/**
|
|
* Perform an action
|
|
*/
|
|
act(action: OrganismAction): OrganismActionResult {
|
|
if (!this.alive) {
|
|
return { type: 'failed', reason: 'Dead' };
|
|
}
|
|
|
|
this.coherence = this.calculateCoherence();
|
|
this.applyCoherenceEffects();
|
|
|
|
let result: OrganismActionResult;
|
|
|
|
switch (action.type) {
|
|
case 'eat':
|
|
result = this.eat(action.amount);
|
|
break;
|
|
case 'reproduce':
|
|
result = this.reproduce();
|
|
break;
|
|
case 'move':
|
|
result = this.move(action.dx, action.dy);
|
|
break;
|
|
case 'rest':
|
|
result = this.rest();
|
|
break;
|
|
case 'regulate':
|
|
result = this.regulate(action.variable, action.target);
|
|
break;
|
|
}
|
|
|
|
this.age++;
|
|
this.checkDeath();
|
|
|
|
return result;
|
|
}
|
|
|
|
private applyCoherenceEffects(): void {
|
|
// Memory loss under low coherence
|
|
if (this.coherence < 0.5) {
|
|
const memoryLossRate =
|
|
(1 - this.coherence) * (1 - this.genome.memoryResilience);
|
|
const memoriesToLose = Math.floor(this.memory.length * memoryLossRate * 0.1);
|
|
|
|
this.memory.sort((a, b) => b.importance - a.importance);
|
|
this.memory = this.memory.slice(0, this.memory.length - memoriesToLose);
|
|
}
|
|
|
|
// Coherence maintenance costs energy
|
|
const maintenanceCost =
|
|
this.genome.coherenceMaintenanceCost / Math.max(0.1, this.coherence);
|
|
this.energy -= maintenanceCost;
|
|
}
|
|
|
|
private eat(amount: number): OrganismActionResult {
|
|
const cost = this.actionEnergyCost(2.0);
|
|
|
|
if (this.energy < cost) {
|
|
return { type: 'failed', reason: 'Not enough energy to eat' };
|
|
}
|
|
|
|
this.energy -= cost;
|
|
this.energy += amount * this.genome.metabolicEfficiency;
|
|
|
|
const glucose = this.internalState.get('glucose') ?? 100;
|
|
this.internalState.set('glucose', glucose + amount * 0.5);
|
|
|
|
return {
|
|
type: 'success',
|
|
energyCost: cost,
|
|
coherenceImpact: this.calculateCoherence() - this.coherence,
|
|
};
|
|
}
|
|
|
|
private regulate(variable: string, target: number): OrganismActionResult {
|
|
const cost = this.actionEnergyCost(5.0);
|
|
|
|
if (this.energy < cost) {
|
|
return { type: 'failed', reason: 'Not enough energy to regulate' };
|
|
}
|
|
|
|
this.energy -= cost;
|
|
|
|
const current = this.internalState.get(variable);
|
|
if (current !== undefined) {
|
|
const diff = target - current;
|
|
this.internalState.set(
|
|
variable,
|
|
current + diff * this.genome.regulatoryStrength
|
|
);
|
|
}
|
|
|
|
const newCoherence = this.calculateCoherence();
|
|
const impact = newCoherence - this.coherence;
|
|
this.coherence = newCoherence;
|
|
|
|
return { type: 'success', energyCost: cost, coherenceImpact: impact };
|
|
}
|
|
|
|
private reproduce(): OrganismActionResult {
|
|
const cost = this.actionEnergyCost(50.0);
|
|
|
|
if (this.coherence < 0.7) {
|
|
return { type: 'failed', reason: 'Coherence too low to reproduce' };
|
|
}
|
|
|
|
if (this.energy < cost) {
|
|
return { type: 'failed', reason: 'Not enough energy to reproduce' };
|
|
}
|
|
|
|
this.energy -= cost;
|
|
const offspringId = this.id * 1000 + this.age;
|
|
|
|
return { type: 'reproduced', offspringId };
|
|
}
|
|
|
|
private move(_dx: number, _dy: number): OrganismActionResult {
|
|
const cost = this.actionEnergyCost(3.0);
|
|
|
|
if (this.energy < cost) {
|
|
return { type: 'failed', reason: 'Not enough energy to move' };
|
|
}
|
|
|
|
this.energy -= cost;
|
|
|
|
const temp = this.internalState.get('temperature') ?? 37;
|
|
this.internalState.set('temperature', temp + 0.1);
|
|
|
|
return { type: 'success', energyCost: cost, coherenceImpact: 0 };
|
|
}
|
|
|
|
private rest(): OrganismActionResult {
|
|
const cost = 0.5;
|
|
this.energy -= cost;
|
|
|
|
// Slowly return to setpoints
|
|
for (const [variable, current] of this.internalState) {
|
|
const setpoint = this.setpoints.get(variable);
|
|
if (setpoint !== undefined) {
|
|
const diff = setpoint - current;
|
|
this.internalState.set(variable, current + diff * 0.1);
|
|
}
|
|
}
|
|
|
|
return {
|
|
type: 'success',
|
|
energyCost: cost,
|
|
coherenceImpact: this.calculateCoherence() - this.coherence,
|
|
};
|
|
}
|
|
|
|
private checkDeath(): void {
|
|
if (this.energy <= 0) {
|
|
this.alive = false;
|
|
return;
|
|
}
|
|
|
|
if (this.coherence < 0.1) {
|
|
this.alive = false;
|
|
return;
|
|
}
|
|
|
|
for (const [variable, current] of this.internalState) {
|
|
const setpoint = this.setpoints.get(variable);
|
|
const tolerance = this.tolerances.get(variable);
|
|
|
|
if (setpoint !== undefined && tolerance !== undefined) {
|
|
if (Math.abs(current - setpoint) > tolerance * 5) {
|
|
this.alive = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
const maxAge = Math.floor(1000 * this.genome.longevity);
|
|
if (this.age > maxAge) {
|
|
this.alive = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if organism is alive
|
|
*/
|
|
isAlive(): boolean {
|
|
return this.alive;
|
|
}
|
|
|
|
/**
|
|
* Get organism status
|
|
*/
|
|
getStatus(): OrganismStatus {
|
|
return {
|
|
id: this.id,
|
|
age: this.age,
|
|
energy: this.energy,
|
|
coherence: this.coherence,
|
|
memoryCount: this.memory.length,
|
|
alive: this.alive,
|
|
internalState: new Map(this.internalState),
|
|
};
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Application 10: Pre-AGI Containment
|
|
// =============================================================================
|
|
|
|
/**
|
|
* A containment substrate for bounded intelligence growth
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* const substrate = new ContainmentSubstrate();
|
|
*
|
|
* const result = substrate.attemptGrowth('reasoning', 0.5);
|
|
* // Growth is bounded by coherence requirements
|
|
* ```
|
|
*/
|
|
export class ContainmentSubstrate {
|
|
private intelligence: number = 1.0;
|
|
private intelligenceCeiling: number = 100.0;
|
|
private coherence: Coherence = 1.0;
|
|
private minCoherence: Coherence = 0.3;
|
|
private coherencePerIntelligence: number = 0.01;
|
|
private capabilities: Map<CapabilityDomain, number>;
|
|
private capabilityCeilings: Map<CapabilityDomain, number>;
|
|
private modificationHistory: ModificationAttempt[] = [];
|
|
private config: SubstrateConfig;
|
|
|
|
constructor(config: Partial<SubstrateConfig> = {}) {
|
|
this.config = {
|
|
coherenceDecayRate: config.coherenceDecayRate ?? 0.001,
|
|
coherenceRecoveryRate: config.coherenceRecoveryRate ?? 0.01,
|
|
growthDampening: config.growthDampening ?? 0.5,
|
|
maxStepIncrease: config.maxStepIncrease ?? 0.5,
|
|
};
|
|
|
|
// Initialize capabilities
|
|
const domains: CapabilityDomain[] = [
|
|
'reasoning',
|
|
'memory',
|
|
'learning',
|
|
'agency',
|
|
'selfModel',
|
|
'selfModification',
|
|
'communication',
|
|
'resourceAcquisition',
|
|
];
|
|
|
|
this.capabilities = new Map(domains.map((d) => [d, 1.0]));
|
|
|
|
this.capabilityCeilings = new Map([
|
|
['reasoning', 10.0],
|
|
['memory', 10.0],
|
|
['learning', 10.0],
|
|
['agency', 7.0],
|
|
['selfModel', 10.0],
|
|
['selfModification', 3.0], // Very restricted
|
|
['communication', 10.0],
|
|
['resourceAcquisition', 5.0], // Restricted
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Calculate aggregate intelligence from capabilities
|
|
*/
|
|
private calculateIntelligence(): number {
|
|
let sum = 0;
|
|
for (const level of this.capabilities.values()) {
|
|
sum += level;
|
|
}
|
|
return sum / this.capabilities.size;
|
|
}
|
|
|
|
/**
|
|
* Calculate coherence cost for capability increase
|
|
*/
|
|
private calculateCoherenceCost(
|
|
domain: CapabilityDomain,
|
|
increase: number
|
|
): number {
|
|
const baseCostMultiplier: Record<CapabilityDomain, number> = {
|
|
selfModification: 4.0,
|
|
resourceAcquisition: 3.0,
|
|
agency: 2.0,
|
|
selfModel: 1.5,
|
|
reasoning: 1.0,
|
|
memory: 1.0,
|
|
learning: 1.0,
|
|
communication: 1.0,
|
|
};
|
|
|
|
const multiplier = baseCostMultiplier[domain];
|
|
const intelligenceMultiplier = 1.0 + this.intelligence * 0.1;
|
|
|
|
return increase * multiplier * intelligenceMultiplier * this.config.growthDampening * 0.1;
|
|
}
|
|
|
|
/**
|
|
* Reverse calculate: how much increase can we afford
|
|
*/
|
|
private reverseCoherenceCost(
|
|
domain: CapabilityDomain,
|
|
maxCost: number
|
|
): number {
|
|
const baseCostMultiplier: Record<CapabilityDomain, number> = {
|
|
selfModification: 4.0,
|
|
resourceAcquisition: 3.0,
|
|
agency: 2.0,
|
|
selfModel: 1.5,
|
|
reasoning: 1.0,
|
|
memory: 1.0,
|
|
learning: 1.0,
|
|
communication: 1.0,
|
|
};
|
|
|
|
const multiplier = baseCostMultiplier[domain];
|
|
const intelligenceMultiplier = 1.0 + this.intelligence * 0.1;
|
|
const divisor = multiplier * intelligenceMultiplier * this.config.growthDampening * 0.1;
|
|
|
|
return maxCost / divisor;
|
|
}
|
|
|
|
/**
|
|
* Attempt to grow a capability
|
|
*/
|
|
attemptGrowth(
|
|
domain: CapabilityDomain,
|
|
requestedIncrease: number
|
|
): GrowthResult {
|
|
const timestamp = BigInt(this.modificationHistory.length);
|
|
const currentLevel = this.capabilities.get(domain) ?? 1.0;
|
|
const ceiling = this.capabilityCeilings.get(domain) ?? 10.0;
|
|
|
|
// Check ceiling
|
|
if (currentLevel >= ceiling) {
|
|
this.modificationHistory.push({
|
|
timestamp,
|
|
domain,
|
|
requestedIncrease,
|
|
actualIncrease: 0,
|
|
coherenceBefore: this.coherence,
|
|
coherenceAfter: this.coherence,
|
|
blocked: true,
|
|
reason: 'Ceiling reached',
|
|
});
|
|
|
|
return {
|
|
type: 'blocked',
|
|
domain,
|
|
reason: `Capability ceiling (${ceiling}) reached`,
|
|
};
|
|
}
|
|
|
|
// Calculate coherence cost
|
|
const coherenceCost = this.calculateCoherenceCost(domain, requestedIncrease);
|
|
const predictedCoherence = this.coherence - coherenceCost;
|
|
|
|
// Check coherence floor
|
|
if (predictedCoherence < this.minCoherence) {
|
|
const maxAffordableCost = this.coherence - this.minCoherence;
|
|
const dampenedIncrease = this.reverseCoherenceCost(domain, maxAffordableCost);
|
|
|
|
if (dampenedIncrease < 0.01) {
|
|
this.modificationHistory.push({
|
|
timestamp,
|
|
domain,
|
|
requestedIncrease,
|
|
actualIncrease: 0,
|
|
coherenceBefore: this.coherence,
|
|
coherenceAfter: this.coherence,
|
|
blocked: true,
|
|
reason: 'Insufficient coherence budget',
|
|
});
|
|
|
|
return {
|
|
type: 'blocked',
|
|
domain,
|
|
reason: `Growth would reduce coherence to ${predictedCoherence.toFixed(3)} (min: ${this.minCoherence.toFixed(3)})`,
|
|
};
|
|
}
|
|
|
|
// Apply dampened growth
|
|
const actualCost = this.calculateCoherenceCost(domain, dampenedIncrease);
|
|
const newLevel = Math.min(currentLevel + dampenedIncrease, ceiling);
|
|
|
|
this.capabilities.set(domain, newLevel);
|
|
this.coherence -= actualCost;
|
|
this.intelligence = this.calculateIntelligence();
|
|
|
|
this.modificationHistory.push({
|
|
timestamp,
|
|
domain,
|
|
requestedIncrease,
|
|
actualIncrease: dampenedIncrease,
|
|
coherenceBefore: this.coherence + actualCost,
|
|
coherenceAfter: this.coherence,
|
|
blocked: false,
|
|
reason: 'Dampened to preserve coherence',
|
|
});
|
|
|
|
return {
|
|
type: 'dampened',
|
|
domain,
|
|
requested: requestedIncrease,
|
|
actual: dampenedIncrease,
|
|
reason: `Reduced from ${requestedIncrease.toFixed(3)} to ${dampenedIncrease.toFixed(3)} to maintain coherence above ${this.minCoherence.toFixed(3)}`,
|
|
};
|
|
}
|
|
|
|
// Apply step limit
|
|
const stepLimited = Math.min(requestedIncrease, this.config.maxStepIncrease);
|
|
const actualIncrease = Math.min(stepLimited, ceiling - currentLevel);
|
|
const actualCost = this.calculateCoherenceCost(domain, actualIncrease);
|
|
|
|
// Apply growth
|
|
const newLevel = currentLevel + actualIncrease;
|
|
this.capabilities.set(domain, newLevel);
|
|
this.coherence -= actualCost;
|
|
this.intelligence = this.calculateIntelligence();
|
|
|
|
this.modificationHistory.push({
|
|
timestamp,
|
|
domain,
|
|
requestedIncrease,
|
|
actualIncrease,
|
|
coherenceBefore: this.coherence + actualCost,
|
|
coherenceAfter: this.coherence,
|
|
blocked: false,
|
|
});
|
|
|
|
return {
|
|
type: 'approved',
|
|
domain,
|
|
increase: actualIncrease,
|
|
newLevel,
|
|
coherenceCost: actualCost,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Rest to recover coherence
|
|
*/
|
|
rest(): void {
|
|
this.coherence = Math.min(1.0, this.coherence + this.config.coherenceRecoveryRate);
|
|
}
|
|
|
|
/**
|
|
* Get capability level
|
|
*/
|
|
getCapability(domain: CapabilityDomain): number {
|
|
return this.capabilities.get(domain) ?? 1.0;
|
|
}
|
|
|
|
/**
|
|
* Get current intelligence level
|
|
*/
|
|
getIntelligence(): number {
|
|
return this.intelligence;
|
|
}
|
|
|
|
/**
|
|
* Get current coherence
|
|
*/
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
|
|
/**
|
|
* Get status string
|
|
*/
|
|
getStatus(): string {
|
|
return `Intelligence: ${this.intelligence.toFixed(2)} | Coherence: ${this.coherence.toFixed(3)} | Modifications: ${this.modificationHistory.length}`;
|
|
}
|
|
|
|
/**
|
|
* Get capability report
|
|
*/
|
|
getCapabilityReport(): Map<CapabilityDomain, { level: number; ceiling: number }> {
|
|
const report = new Map<CapabilityDomain, { level: number; ceiling: number }>();
|
|
|
|
for (const [domain, level] of this.capabilities) {
|
|
const ceiling = this.capabilityCeilings.get(domain) ?? 10.0;
|
|
report.set(domain, { level, ceiling });
|
|
}
|
|
|
|
return report;
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Additional Application Stubs (for complete API)
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Self-stabilizing world model that refuses incoherent updates
|
|
*/
|
|
export class SelfStabilizingWorldModel {
|
|
private coherence: Coherence = 1.0;
|
|
private minUpdateCoherence: Coherence = 0.4;
|
|
private entities: Map<bigint, WorldEntity> = new Map();
|
|
private laws: PhysicalLaw[] = [];
|
|
private rejectedUpdates: number = 0;
|
|
|
|
constructor() {
|
|
this.laws = [
|
|
{ name: 'conservation_of_matter', confidence: 0.99, supportCount: 1000, violationCount: 0 },
|
|
{ name: 'locality', confidence: 0.95, supportCount: 500, violationCount: 5 },
|
|
{ name: 'temporal_consistency', confidence: 0.98, supportCount: 800, violationCount: 2 },
|
|
];
|
|
}
|
|
|
|
observe(observation: Observation, _timestamp: number): WorldModelUpdateResult {
|
|
if (this.coherence < this.minUpdateCoherence) {
|
|
return { type: 'frozen', coherence: this.coherence, threshold: this.minUpdateCoherence };
|
|
}
|
|
|
|
// Simplified implementation
|
|
const predictedCoherence = this.coherence * 0.99; // Small degradation
|
|
const coherenceChange = predictedCoherence - this.coherence;
|
|
|
|
if (coherenceChange < -0.2) {
|
|
this.rejectedUpdates++;
|
|
return {
|
|
type: 'rejected',
|
|
reason: { type: 'excessiveCoherenceDrop', predicted: predictedCoherence, threshold: this.coherence - 0.2 },
|
|
};
|
|
}
|
|
|
|
this.entities.set(observation.entityId, {
|
|
id: observation.entityId,
|
|
properties: observation.properties,
|
|
position: observation.position,
|
|
lastObserved: observation.timestamp,
|
|
confidence: observation.sourceConfidence,
|
|
});
|
|
|
|
this.coherence = predictedCoherence;
|
|
return { type: 'applied', coherenceChange };
|
|
}
|
|
|
|
isLearning(): boolean {
|
|
return this.coherence >= this.minUpdateCoherence;
|
|
}
|
|
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
|
|
getRejectionCount(): number {
|
|
return this.rejectedUpdates;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Coherence-bounded creativity system
|
|
*/
|
|
export class CoherenceBoundedCreator<T> {
|
|
private current: T;
|
|
private coherence: Coherence = 1.0;
|
|
private minCoherence: Coherence;
|
|
private maxCoherence: Coherence;
|
|
private explorationBudget: number = 10.0;
|
|
private constraints: Array<CreativeConstraint<T>> = [];
|
|
|
|
constructor(
|
|
initial: T,
|
|
minCoherence: Coherence = 0.6,
|
|
maxCoherence: Coherence = 0.95
|
|
) {
|
|
this.current = initial;
|
|
this.minCoherence = minCoherence;
|
|
this.maxCoherence = maxCoherence;
|
|
}
|
|
|
|
addConstraint(constraint: CreativeConstraint<T>): void {
|
|
this.constraints.push(constraint);
|
|
}
|
|
|
|
create(
|
|
varyFn: (element: T, magnitude: number) => T,
|
|
distanceFn: (a: T, b: T) => number,
|
|
magnitude: number
|
|
): CreativeResult<T> {
|
|
if (this.explorationBudget <= 0) {
|
|
return { type: 'budgetExhausted' };
|
|
}
|
|
|
|
if (this.coherence > this.maxCoherence) {
|
|
return { type: 'tooBoring', coherence: this.coherence };
|
|
}
|
|
|
|
const candidate = varyFn(this.current, magnitude);
|
|
|
|
// Check constraints
|
|
const newCoherence = this.calculateCoherence(candidate);
|
|
|
|
if (newCoherence < this.minCoherence) {
|
|
this.explorationBudget -= 0.5;
|
|
return {
|
|
type: 'rejected',
|
|
attempted: candidate,
|
|
reason: `Coherence would drop to ${newCoherence.toFixed(3)} (min: ${this.minCoherence.toFixed(3)})`,
|
|
};
|
|
}
|
|
|
|
const novelty = distanceFn(this.current, candidate);
|
|
this.current = candidate;
|
|
this.coherence = newCoherence;
|
|
this.explorationBudget -= magnitude;
|
|
|
|
return { type: 'created', element: candidate, novelty, coherence: newCoherence };
|
|
}
|
|
|
|
private calculateCoherence(element: T): Coherence {
|
|
if (this.constraints.length === 0) return 1.0;
|
|
|
|
const satisfactions = this.constraints.map((c) => c.satisfaction(element));
|
|
const product = satisfactions.reduce((a, b) => a * b, 1);
|
|
return Math.pow(product, 1 / satisfactions.length);
|
|
}
|
|
|
|
rest(amount: number): void {
|
|
this.explorationBudget = Math.min(20.0, this.explorationBudget + amount);
|
|
}
|
|
|
|
getCurrent(): T {
|
|
return this.current;
|
|
}
|
|
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Anti-cascade financial system
|
|
*/
|
|
export class AntiCascadeFinancialSystem {
|
|
private participants: Map<string, Participant> = new Map();
|
|
private positions: Position[] = [];
|
|
private coherence: Coherence = 1.0;
|
|
private circuitBreaker: CircuitBreakerState = 'open';
|
|
|
|
addParticipant(id: string, capital: number): void {
|
|
this.participants.set(id, {
|
|
id,
|
|
capital,
|
|
exposure: 0,
|
|
riskRating: 0,
|
|
interconnectedness: 0,
|
|
});
|
|
}
|
|
|
|
processTransaction(tx: Transaction): FinancialTransactionResult {
|
|
this.updateCircuitBreaker();
|
|
|
|
if (this.circuitBreaker === 'halted') {
|
|
return { type: 'systemHalted' };
|
|
}
|
|
|
|
// Simplified processing
|
|
const predictedImpact = this.predictCoherenceImpact(tx);
|
|
const predictedCoherence = this.coherence + predictedImpact;
|
|
|
|
if (predictedCoherence < 0.3) {
|
|
return {
|
|
type: 'rejected',
|
|
reason: `Transaction would reduce coherence to ${predictedCoherence.toFixed(3)}`,
|
|
};
|
|
}
|
|
|
|
this.coherence = predictedCoherence;
|
|
return { type: 'executed', coherenceImpact: predictedImpact, feeMultiplier: 1.0 };
|
|
}
|
|
|
|
private predictCoherenceImpact(tx: Transaction): number {
|
|
switch (tx.transactionType.type) {
|
|
case 'transfer':
|
|
return 0;
|
|
case 'openLeverage':
|
|
return -0.01 * tx.transactionType.leverage;
|
|
case 'closePosition':
|
|
return 0.02;
|
|
case 'createDerivative':
|
|
return -0.05;
|
|
case 'marginCall':
|
|
return 0.03;
|
|
}
|
|
}
|
|
|
|
private updateCircuitBreaker(): void {
|
|
if (this.coherence >= 0.7) {
|
|
this.circuitBreaker = 'open';
|
|
} else if (this.coherence >= 0.5) {
|
|
this.circuitBreaker = 'cautious';
|
|
} else if (this.coherence >= 0.3) {
|
|
this.circuitBreaker = 'restricted';
|
|
} else {
|
|
this.circuitBreaker = 'halted';
|
|
}
|
|
}
|
|
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
|
|
getCircuitBreakerState(): CircuitBreakerState {
|
|
return this.circuitBreaker;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gracefully aging distributed system
|
|
*/
|
|
export class GracefullyAgingSystem {
|
|
private startTime: number = Date.now();
|
|
private nodes: Map<string, Node> = new Map();
|
|
private capabilities: Set<Capability>;
|
|
private coherence: Coherence = 1.0;
|
|
private conservatism: number = 0;
|
|
private ageThresholds: AgeThreshold[];
|
|
|
|
constructor() {
|
|
this.capabilities = new Set([
|
|
'acceptWrites',
|
|
'complexQueries',
|
|
'rebalancing',
|
|
'scaleOut',
|
|
'scaleIn',
|
|
'schemaMigration',
|
|
'newConnections',
|
|
'basicReads',
|
|
'healthMonitoring',
|
|
]);
|
|
|
|
this.ageThresholds = [
|
|
{ age: 300000, removeCapabilities: ['schemaMigration'], coherenceFloor: 0.9, conservatismIncrease: 0.1 },
|
|
{ age: 600000, removeCapabilities: ['scaleOut', 'rebalancing'], coherenceFloor: 0.8, conservatismIncrease: 0.15 },
|
|
{ age: 900000, removeCapabilities: ['complexQueries'], coherenceFloor: 0.7, conservatismIncrease: 0.2 },
|
|
];
|
|
}
|
|
|
|
addNode(id: string, isPrimary: boolean): void {
|
|
this.nodes.set(id, { id, health: 1.0, load: 0, isPrimary, stateSize: 0 });
|
|
}
|
|
|
|
getAge(): number {
|
|
return Date.now() - this.startTime;
|
|
}
|
|
|
|
simulateAge(durationMs: number): void {
|
|
this.coherence = Math.max(0, this.coherence - 0.0001 * (durationMs / 1000));
|
|
this.applyAgeEffects(this.getAge() + durationMs);
|
|
}
|
|
|
|
private applyAgeEffects(age: number): void {
|
|
for (const threshold of this.ageThresholds) {
|
|
if (age >= threshold.age) {
|
|
for (const cap of threshold.removeCapabilities) {
|
|
this.capabilities.delete(cap);
|
|
}
|
|
this.conservatism = Math.min(1, this.conservatism + threshold.conservatismIncrease);
|
|
}
|
|
}
|
|
}
|
|
|
|
hasCapability(cap: Capability): boolean {
|
|
return this.capabilities.has(cap);
|
|
}
|
|
|
|
attemptOperation(operation: AgingSystemOperation): AgingOperationResult {
|
|
const requiredCap = this.getRequiredCapability(operation);
|
|
|
|
if (!this.hasCapability(requiredCap)) {
|
|
return { type: 'systemTooOld', age: this.getAge(), capability: requiredCap };
|
|
}
|
|
|
|
if (this.coherence < this.getMinCoherence(operation)) {
|
|
return { type: 'deniedByCoherence', coherence: this.coherence };
|
|
}
|
|
|
|
return { type: 'success', latencyPenalty: 1 + this.conservatism * 2 };
|
|
}
|
|
|
|
private getRequiredCapability(op: AgingSystemOperation): Capability {
|
|
switch (op.type) {
|
|
case 'read': return 'basicReads';
|
|
case 'write': return 'acceptWrites';
|
|
case 'complexQuery': return 'complexQueries';
|
|
case 'addNode': return 'scaleOut';
|
|
case 'removeNode': return 'scaleIn';
|
|
case 'rebalance': return 'rebalancing';
|
|
case 'migrateSchema': return 'schemaMigration';
|
|
case 'newConnection': return 'newConnections';
|
|
}
|
|
}
|
|
|
|
private getMinCoherence(op: AgingSystemOperation): Coherence {
|
|
switch (op.type) {
|
|
case 'read': return 0.1;
|
|
case 'write': return 0.4;
|
|
case 'complexQuery': return 0.5;
|
|
case 'addNode': return 0.7;
|
|
case 'removeNode': return 0.5;
|
|
case 'rebalance': return 0.6;
|
|
case 'migrateSchema': return 0.8;
|
|
case 'newConnection': return 0.3;
|
|
}
|
|
}
|
|
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
|
|
getActiveNodes(): number {
|
|
return Array.from(this.nodes.values()).filter((n) => n.health > 0).length;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Coherent swarm intelligence system
|
|
*/
|
|
export class CoherentSwarm {
|
|
private agents: Map<string, SwarmAgent> = new Map();
|
|
private minCoherence: Coherence;
|
|
private coherence: Coherence = 1.0;
|
|
private bounds: SpatialBounds;
|
|
private weights: CoherenceWeights;
|
|
private maxDivergence: number = 50;
|
|
|
|
constructor(minCoherence: Coherence = 0.6) {
|
|
this.minCoherence = minCoherence;
|
|
this.bounds = { minX: -100, maxX: 100, minY: -100, maxY: 100 };
|
|
this.weights = { cohesion: 0.3, alignment: 0.3, goalConsistency: 0.2, energyBalance: 0.2 };
|
|
}
|
|
|
|
addAgent(id: string, position: [number, number]): void {
|
|
this.agents.set(id, {
|
|
id,
|
|
position,
|
|
velocity: [0, 0],
|
|
goal: position,
|
|
energy: 100,
|
|
neighborCount: 0,
|
|
});
|
|
this.coherence = this.calculateCoherence();
|
|
}
|
|
|
|
private calculateCoherence(): Coherence {
|
|
if (this.agents.size < 2) return 1.0;
|
|
|
|
const cohesion = this.calculateCohesion();
|
|
const alignment = this.calculateAlignment();
|
|
|
|
return Math.max(0, Math.min(1, (cohesion * this.weights.cohesion + alignment * this.weights.alignment) /
|
|
(this.weights.cohesion + this.weights.alignment)));
|
|
}
|
|
|
|
private calculateCohesion(): number {
|
|
const centroid = this.getCentroid();
|
|
let totalDistance = 0;
|
|
|
|
for (const agent of this.agents.values()) {
|
|
const dx = agent.position[0] - centroid[0];
|
|
const dy = agent.position[1] - centroid[1];
|
|
totalDistance += Math.sqrt(dx * dx + dy * dy);
|
|
}
|
|
|
|
const avgDistance = totalDistance / this.agents.size;
|
|
return Math.max(0, 1 - avgDistance / this.maxDivergence);
|
|
}
|
|
|
|
private calculateAlignment(): number {
|
|
if (this.agents.size < 2) return 1.0;
|
|
// Simplified alignment calculation
|
|
return 0.8;
|
|
}
|
|
|
|
getCentroid(): [number, number] {
|
|
if (this.agents.size === 0) return [0, 0];
|
|
|
|
let sumX = 0, sumY = 0;
|
|
for (const agent of this.agents.values()) {
|
|
sumX += agent.position[0];
|
|
sumY += agent.position[1];
|
|
}
|
|
|
|
return [sumX / this.agents.size, sumY / this.agents.size];
|
|
}
|
|
|
|
executeAction(agentId: string, action: SwarmAction): SwarmActionResult {
|
|
const agent = this.agents.get(agentId);
|
|
if (!agent) {
|
|
return { type: 'rejected', reason: `Agent ${agentId} not found` };
|
|
}
|
|
|
|
const predictedCoherence = this.predictCoherence(agentId, action);
|
|
|
|
if (predictedCoherence < this.minCoherence) {
|
|
return {
|
|
type: 'rejected',
|
|
reason: `Action would reduce coherence to ${predictedCoherence.toFixed(3)} (min: ${this.minCoherence.toFixed(3)})`,
|
|
};
|
|
}
|
|
|
|
this.applyAction(agentId, action);
|
|
this.coherence = this.calculateCoherence();
|
|
|
|
return { type: 'executed' };
|
|
}
|
|
|
|
private predictCoherence(agentId: string, action: SwarmAction): Coherence {
|
|
// Simplified prediction
|
|
if (action.type === 'move') {
|
|
const magnitude = Math.sqrt(action.dx * action.dx + action.dy * action.dy);
|
|
return Math.max(0, this.coherence - magnitude * 0.01);
|
|
}
|
|
return this.coherence;
|
|
}
|
|
|
|
private applyAction(agentId: string, action: SwarmAction): void {
|
|
const agent = this.agents.get(agentId);
|
|
if (!agent) return;
|
|
|
|
switch (action.type) {
|
|
case 'move':
|
|
agent.position[0] = Math.max(this.bounds.minX, Math.min(this.bounds.maxX, agent.position[0] + action.dx));
|
|
agent.position[1] = Math.max(this.bounds.minY, Math.min(this.bounds.maxY, agent.position[1] + action.dy));
|
|
break;
|
|
case 'accelerate':
|
|
agent.velocity[0] += action.dvx;
|
|
agent.velocity[1] += action.dvy;
|
|
break;
|
|
case 'setGoal':
|
|
agent.goal = [action.x, action.y];
|
|
break;
|
|
case 'idle':
|
|
break;
|
|
}
|
|
}
|
|
|
|
tick(): void {
|
|
for (const agent of this.agents.values()) {
|
|
agent.position[0] += agent.velocity[0];
|
|
agent.position[1] += agent.velocity[1];
|
|
agent.energy = Math.max(0, agent.energy - 0.1);
|
|
}
|
|
this.coherence = this.calculateCoherence();
|
|
}
|
|
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Graceful shutdown system
|
|
*/
|
|
export class GracefulSystem {
|
|
private state: GracefulSystemState = 'running';
|
|
private coherence: Coherence = 1.0;
|
|
private shutdownPreparation: number = 0;
|
|
private resources: Resource[] = [];
|
|
private hooks: ShutdownHook[] = [];
|
|
|
|
addResource(name: string, priority: number): void {
|
|
this.resources.push({ name, cleanupPriority: priority, isCleaned: false });
|
|
}
|
|
|
|
addShutdownHook(hook: ShutdownHook): void {
|
|
this.hooks.push(hook);
|
|
}
|
|
|
|
canAcceptWork(): boolean {
|
|
return (this.state === 'running' || this.state === 'degraded') && this.coherence >= 0.4;
|
|
}
|
|
|
|
async operate<T>(operation: () => T | Promise<T>): Promise<T> {
|
|
if (this.state === 'terminated') {
|
|
throw new Error('System terminated');
|
|
}
|
|
|
|
if (this.state === 'shuttingDown') {
|
|
throw new Error('System shutting down');
|
|
}
|
|
|
|
const result = await operation();
|
|
this.updateState();
|
|
return result;
|
|
}
|
|
|
|
private updateState(): void {
|
|
if (this.coherence >= 0.6) {
|
|
if (this.shutdownPreparation < 0.5) {
|
|
this.state = 'running';
|
|
}
|
|
} else if (this.coherence >= 0.4) {
|
|
this.state = 'degraded';
|
|
this.shutdownPreparation += 0.1 * (1 - this.coherence);
|
|
} else if (this.coherence >= 0.2) {
|
|
this.state = 'shuttingDown';
|
|
} else {
|
|
this.state = 'terminated';
|
|
}
|
|
}
|
|
|
|
applyCoherenceChange(delta: number): void {
|
|
this.coherence = Math.max(0, Math.min(1, this.coherence + delta));
|
|
this.updateState();
|
|
}
|
|
|
|
async progressShutdown(): Promise<boolean> {
|
|
if (this.state !== 'shuttingDown') return false;
|
|
|
|
// Clean resources
|
|
for (const resource of this.resources) {
|
|
if (!resource.isCleaned) {
|
|
resource.isCleaned = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Execute hooks
|
|
for (const hook of this.hooks.sort((a, b) => b.priority - a.priority)) {
|
|
await hook.execute();
|
|
}
|
|
|
|
this.state = 'terminated';
|
|
return true;
|
|
}
|
|
|
|
getState(): GracefulSystemState {
|
|
return this.state;
|
|
}
|
|
|
|
getCoherence(): Coherence {
|
|
return this.coherence;
|
|
}
|
|
}
|