@holoscript/core 6.0.4 → 6.1.2

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export interface ASTNode {
 }
 
 export interface ParseResult {
+  success?: boolean;
   ast: any;
   errors: any[];
   warnings: any[];
@@ -34,6 +35,140 @@ export interface ParsedTrait {
   [key: string]: any;
 }
 
+export interface ReconstructionManifest {
+  version: '1.0.0';
+  worldId: string;
+  displayName: string;
+  createdAt: string;
+  frameCount: number;
+  bounds: { min: [number, number, number]; max: [number, number, number] };
+  replayHash: string;
+  simulationContract: {
+    kind: 'holomap.reconstruction.v1';
+    replayFingerprint: string;
+    holoScriptBuild: string;
+  };
+  [key: string]: unknown;
+}
+
+export function assertHoloMapManifestContract(m: ReconstructionManifest): void;
+
+export const DOMAIN_SIMULATION_RECEIPT_SCHEMA: 'holoscript.domain-simulation-receipt.v0.1.0';
+export type DomainSimulationReceiptSchema = typeof DOMAIN_SIMULATION_RECEIPT_SCHEMA;
+export type DomainSimulationReceiptHashAlgorithm = 'fnv1a32';
+export type DomainReceiptJson =
+  | string
+  | number
+  | boolean
+  | null
+  | DomainReceiptJson[]
+  | { [key: string]: DomainReceiptJson };
+export interface DomainSimulationReceiptAcceptance {
+  accepted: boolean;
+  violations: Array<{ criterion: string; message: string }>;
+}
+export interface DomainSimulationReceiptInput {
+  plugin: string;
+  pluginVersion: string;
+  runId: string;
+  createdAt?: string;
+  modelId?: string;
+  solverConfig: {
+    solverType: string;
+    scale: string;
+    [key: string]: DomainReceiptJson;
+  };
+  resultSummary: { [key: string]: DomainReceiptJson };
+  acceptance: DomainSimulationReceiptAcceptance;
+  cael?: {
+    version?: 'cael.v1';
+    event?: string;
+    solverType?: string;
+  };
+  artifacts?: Array<{
+    kind: string;
+    path?: string;
+    hash?: string;
+  }>;
+}
+export interface DomainSimulationReceipt {
+  schema: DomainSimulationReceiptSchema;
+  plugin: string;
+  pluginVersion: string;
+  runId: string;
+  createdAt: string;
+  modelId?: string;
+  solverConfig: {
+    solverType: string;
+    scale: string;
+    [key: string]: DomainReceiptJson;
+  };
+  resultSummary: { [key: string]: DomainReceiptJson };
+  cael: {
+    version: 'cael.v1';
+    event: string;
+    solverType: string;
+  };
+  acceptance: DomainSimulationReceiptAcceptance;
+  artifacts?: Array<{
+    kind: string;
+    path?: string;
+    hash?: string;
+  }>;
+  payloadHash: string;
+  hashAlgorithm: DomainSimulationReceiptHashAlgorithm;
+}
+export interface DomainSimulationReceiptVerification {
+  valid: boolean;
+  errors: string[];
+}
+export function buildDomainSimulationReceipt(input: DomainSimulationReceiptInput): DomainSimulationReceipt;
+export function verifyDomainSimulationReceipt(receipt: DomainSimulationReceipt): DomainSimulationReceiptVerification;
+export function stableDomainReceiptHash(payload: unknown): string;
+export function canonicalizeDomainReceiptPayload(payload: unknown): string;
+
+export const SCALE_BRIDGE_PROJECTION_SCHEMA: 'holoscript.scale-bridge.projection.v0.1.0';
+export type ScaleBridgeProjectionSchema = typeof SCALE_BRIDGE_PROJECTION_SCHEMA;
+export type ScaleBridgeJson =
+  | string
+  | number
+  | boolean
+  | null
+  | ScaleBridgeJson[]
+  | { [key: string]: ScaleBridgeJson };
+export interface ScaleDescriptor {
+  id: string;
+  label?: string;
+  granularity?: string;
+  includePaths?: string[];
+  excludePaths?: string[];
+  collectionLimits?: Record<string, number>;
+  collectionStride?: Record<string, number>;
+  defaultStride?: number;
+  metadata?: { [key: string]: ScaleBridgeJson };
+}
+export interface ScaleBridgeProvenanceEdge {
+  type: 'scale_projection';
+  hashAlgorithm: 'sha256';
+  sourceStateHash: string;
+  projectedStateHash: string;
+  targetScaleId: string;
+}
+export interface ScaleBridgeProjection<TState extends ScaleBridgeJson = ScaleBridgeJson> {
+  schema: ScaleBridgeProjectionSchema;
+  targetScale: ScaleDescriptor;
+  state: TState;
+  provenance: {
+    edge: ScaleBridgeProvenanceEdge;
+    carriedReceipts: ScaleBridgeJson[];
+  };
+}
+export class ScaleBridge {
+  static project(sourceState: unknown, scaleDescriptor: ScaleDescriptor): ScaleBridgeProjection;
+  static hashState(state: unknown): string;
+}
+export function canonicalizeScaleBridgeJson(value: unknown): string;
+
 // ============================================================================
 // PARSERS
 // ============================================================================
@@ -44,6 +179,57 @@ export class HoloScriptPlusParser {
   parseStatement(source: string): any;
 }
 
+export interface ParseCacheStats {
+  size: number;
+  evictions: number;
+  maxEntries: number;
+}
+
+export interface ParseCache {
+  get(id: string, currentHash: string): any | null;
+  set(id: string, hash: string, node: any): void;
+  clear(): void;
+  getStats(): ParseCacheStats;
+}
+
+export const globalParseCache: ParseCache;
+
+export interface IncrementalParseResult {
+  ast: any;
+  cached: number;
+  parsed: number;
+  duration: number;
+  changedChunks: string[];
+}
+
+export class ChunkBasedIncrementalParser {
+  constructor(cache?: ParseCache);
+  parse(source: string): IncrementalParseResult;
+  clearCache(): void;
+  getCacheStats(): ParseCacheStats;
+}
+
+export class HSPlusRuntime {
+  constructor(options?: any);
+  mount(container: any): void;
+  unmount(): void;
+  update(delta: number): void;
+  setState(updates: Record<string, any>): void;
+  getState(): Record<string, any>;
+  on(event: string, handler: (payload: any) => void): () => void;
+  emit(event: string, payload?: any): void;
+}
+
+export class World {
+  constructor();
+  createEntity(): string;
+  removeEntity(id: string): void;
+}
+
+export class ComponentRegistry {
+  static register(name: string, component: any): void;
+}
+
 export class HoloCompositionParser {
   parse(source: string): any;
 }
@@ -59,6 +245,8 @@ export function parse(source: string, options?: any): ParseResult;
 export function parseHolo(source: string, options?: any): any;
 export function parseHoloStrict(source: string): any;
 export function parseHoloScriptPlus(source: string, options?: any): ParseResult;
+export const holoFactory: any;
+export function generateHoloSource(ast: any): string;
 
 // ============================================================================
 // COMPOSITION TYPES (from .holo files)
@@ -114,6 +302,8 @@ export interface HoloObjectTrait extends ASTNode {
   type: 'Trait';
   name: string;
   config?: any;
+  args?: any[];
+  platformConstraint?: PlatformConstraint;
 }
 
 export interface HoloSpatialGroup extends ASTNode {
@@ -140,6 +330,10 @@ export interface HoloAction extends ASTNode {
   [key: string]: any;
 }
 
+export interface HoloStatement extends ASTNode {
+  [key: string]: any;
+}
+
 export interface HoloParseResult {
   success: boolean;
   ast?: HoloComposition;
@@ -414,12 +608,14 @@ export class AdvancedCompression {
 }
 
 export interface INeuralSplatPacket {
-  id: string;
-  frameId?: number;
-  count: number;
-  data: Uint8Array;
-  metadata?: Record<string, any>;
-  cameraState?: any;
+  frameId: number;
+  cameraState: {
+    viewProjectionMatrix: number[];
+    cameraPosition: number[];
+  };
+  splatCount: number;
+  compressedSplatsBuffer: ArrayBuffer;
+  sortedIndicesBuffer: ArrayBuffer;
 }
 
 // ============================================================================
@@ -534,8 +730,10 @@ export function compileForIsaacSim(composition: HoloComposition, options?: Parti
 // ============================================================================
 
 export class ExpressionEvaluator {
+  constructor(context?: Record<string, unknown>, builtins?: Record<string, unknown>);
   evaluate(expression: string, context?: any): any;
   extractVariables(expression: string): string[];
+  updateContext(updates: Record<string, unknown>): void;
 }
 
 export class EventBus {
@@ -648,9 +846,11 @@ export interface HoloTemplate {
   [key: string]: any;
 }
 export interface HSPlusForDirective {
-  iterable: string;
+  type: 'for';
   variable: string;
-  body?: any[];
+  range?: [number, number];
+  iterable?: string;
+  body: unknown[];
 }
 export interface RaycastHit {
   point: Vector3;
@@ -661,7 +861,27 @@ export interface RaycastHit {
 }
 
 export class HoloScriptRuntime {
+  constructor(importLoader?: any, customFunctions?: any);
   execute(ast: any, context?: any): Promise<any>;
+  executeProgram(nodes: any[], depth?: number): Promise<any[]>;
+  executeHoloProgram(statements: any[], scopeOverride?: any): Promise<any[]>;
+  getContext(): any;
+  reset(): void;
+  startVisualizationServer(port?: number): void;
+  broadcast(type: string, payload: unknown): void;
+  on(event: string, handler: (...args: any[]) => any): void;
+  off(event: string, handler?: (...args: any[]) => any): void;
+  emit(event: string, data?: unknown): Promise<void>;
+  setVariable(name: string, value: any, scopeOverride?: any): void;
+  getVariable(name: string, scopeOverride?: any): any;
+  callFunction(name: string, args?: any[]): Promise<any>;
+  registerFunction(name: string, handler: (...args: any[]) => any): void;
+  registerTrait(name: string, handler: any): void;
+  getState(): Record<string, any>;
+  getRootScope(): any;
+  getExecutionHistory(): any[];
+  getCallStack(): string[];
+  [key: string]: any;
 }
 
 export interface RuntimeOptions {
@@ -684,6 +904,10 @@ export interface ExecutionResult {
   error?: string;
   duration?: number;
   memoryUsed?: number;
+  executionTime?: number;
+  hologram?: { shape?: string; color?: string; [key: string]: any };
+  spatialPosition?: { x: number; y: number; z: number; [key: string]: any };
+  output?: any;
 }
 
 export interface SpatialPosition {
@@ -801,6 +1025,11 @@ export interface SafetyReport {
 }
 
 export type SafetyVerdict = 'safe' | 'warnings' | 'unsafe' | 'unchecked';
+export type VREffect = string;
+export type EffectCategory = string;
+export type EffectViolationSeverity = 'error' | 'warning' | 'info';
+export interface EffectViolation { effect: VREffect; severity: EffectViolationSeverity; [key: string]: any; }
+export interface EffectDeclaration { effects: VREffect[]; [key: string]: any; }
 
 // ============================================================================
 // PLATFORM TYPES
@@ -869,18 +1098,26 @@ export class SemanticSearchService<T = any> {
 // VR TRAIT SYSTEM TYPES
 // ============================================================================
 
-export interface Vector3 {
-  x: number;
-  y: number;
-  z: number;
-}
+// Vector3 is a tuple in source (packages/core/src/types/HoloScriptPlus.ts:10).
+// Emitting as {x,y,z} interface here in 2026-04-22..04-25 produced hundreds
+// of engine-package TS errors like "Type 'number[]' is missing properties
+// x,y,z from Vector3" because consumer code correctly uses tuple-form
+// (engine/src/animation/IKSolver.ts:139, etc). Restoring tuple form here
+// lets pre-flight pass; for {x,y,z} object shape use three.Vector3 directly.
+export type Vector3 = [number, number, number];
 
 export interface VRHand {
+  id: string;
   position: Vector3;
-  rotation: Vector3;
-  joints: Map<string, { position: Vector3; rotation: Vector3 }>;
-  pinchStrength: number;
-  gripStrength: number;
+  rotation: Quaternion;
+  velocity: Vector3;
+  joints?: Map<string, { position: Vector3; rotation: Vector3 }>;
+  pinch?: number;
+  pinchStrength?: number;
+  grip: number;
+  gripStrength?: number;
+  trigger: number;
+  pointing?: boolean;
 }
 
 export interface VRContext {
@@ -895,8 +1132,8 @@ export interface PhysicsContext {
   applyAngularVelocity(node: HSPlusNode, angularVelocity: Vector3): void;
   setKinematic(node: HSPlusNode, kinematic: boolean): void;
   raycast(origin: Vector3, direction: Vector3, maxDistance: number): RaycastHit | null;
-  getBodyPosition(nodeId: string): { x: number; y: number; z: number } | null;
-  getBodyVelocity(nodeId: string): { x: number; y: number; z: number } | null;
+  getBodyPosition(nodeId: string): Vector3 | null;
+  getBodyVelocity(nodeId: string): Vector3 | null;
 }
 
 export interface AudioContext {
@@ -919,12 +1156,32 @@ export interface AccessibilityContext {
   setHighContrast(enabled: boolean): void;
 }
 
+export type ARTrackingState = 'not_available' | 'limited' | 'normal' | 'lost';
+
+export interface ARSessionPose {
+  anchorId?: string;
+  target?: string;
+  position: Vector3;
+  rotation?: Vector3;
+  confidence?: number;
+  timestampMs?: number;
+  trackingState?: ARTrackingState;
+  source?: string;
+}
+
+export interface ARSessionContext {
+  readonly available: boolean;
+  getPose(nodeId?: string): ARSessionPose | null;
+  getAnchor?(anchorId: string): ARSessionPose | null;
+}
+
 export interface TraitContext {
   vr: VRContext;
   physics: PhysicsContext;
   audio: AudioContext;
   haptics: HapticsContext;
   accessibility?: AccessibilityContext;
+  arSession?: ARSessionContext;
   emit(event: string, payload?: unknown): void;
   getState(): Record<string, unknown>;
   setState(updates: Record<string, unknown>): void;
@@ -966,6 +1223,8 @@ export class ProceduralSkill {
 export type VRTraitName = string;
 
 export class VRTraitRegistry {
+  register(handler: TraitHandler): void;
+  getHandler(name: VRTraitName): TraitHandler | undefined;
   attachTrait(node: HSPlusNode, traitName: VRTraitName, config: unknown, context: TraitContext): void;
   detachTrait(node: HSPlusNode, traitName: VRTraitName, context: TraitContext): void;
   updateAllTraits(node: HSPlusNode, context: TraitContext, delta: number): void;
@@ -1494,11 +1753,11 @@ export declare class AIDriverTrait {
 // CROSS-PLATFORM COMPILERS (re-exported from compiler subpaths)
 // ============================================================================
 
-export class UnityCompiler { compile(ast: any, options?: any): any; [key: string]: any; }
-export class GodotCompiler { compile(ast: any, options?: any): any; [key: string]: any; }
-export class VisionOSCompiler { compile(ast: any, options?: any): any; [key: string]: any; }
-export class VRChatCompiler { compile(ast: any, options?: any): any; [key: string]: any; }
-export class UnrealCompiler { compile(ast: any, options?: any): any; [key: string]: any; }
+export class UnityCompiler { constructor(options?: any); compile(ast: any, options?: any): any; [key: string]: any; }
+export class GodotCompiler { constructor(options?: any); compile(ast: any, options?: any): any; [key: string]: any; }
+export class VisionOSCompiler { constructor(options?: any); compile(ast: any, options?: any): any; [key: string]: any; }
+export class VRChatCompiler { constructor(options?: any); compile(ast: any, options?: any): any; [key: string]: any; }
+export class UnrealCompiler { constructor(options?: any); compile(ast: any, options?: any): any; [key: string]: any; }
 
 // ============================================================================
 // REACTIVE STATE SYSTEM
@@ -1628,6 +1887,35 @@ export interface CulturalNorm {
 export type NormCategory = string;
 export type NormEnforcement = 'hard' | 'soft' | 'advisory';
 export type NormScope = 'agent' | 'zone' | 'world' | 'session';
+export type NormProvenanceSource =
+  | 'agent'
+  | 'corpus'
+  | 'declaration_site'
+  | 'builtin'
+  | 'observation'
+  | 'unknown';
+export interface NormProvenance {
+  source: NormProvenanceSource;
+  sourceAgentId?: string;
+  sourceCorpus?: string;
+  declarationSite?: {
+    file: string;
+    line?: number;
+    column?: number;
+  };
+  originInteractionId?: string;
+  confidenceClassification?: 'genuine' | 'confabulated' | 'bullshitted';
+  recordedAtIso?: string;
+}
+export declare const UNKNOWN_NORM_PROVENANCE: Readonly<NormProvenance>;
+export declare const BUILTIN_NORM_PROVENANCE: Readonly<NormProvenance>;
+export declare function normalizeNormProvenance(
+  value: Partial<NormProvenance> | undefined | null
+): NormProvenance;
+export declare function serializeNormProvenance(
+  value: NormProvenance | undefined | null
+): Record<string, unknown>;
+export declare function deserializeNormProvenance(value: unknown): NormProvenance;
 
 // ============================================================================
 // MARKETPLACE
@@ -2066,12 +2354,14 @@ export interface CompilerOptions { target?: string; optimize?: boolean; [key: st
 export interface CompilerDiagnostic { severity: 'error' | 'warning' | 'info'; message: string; line?: number; column?: number; [key: string]: any; }
 export interface IncrementalBuildResult { success: boolean; diagnostics: CompilerDiagnostic[]; artifacts: any[]; [key: string]: any; }
 export declare class IncrementalCompiler {
+  static deserialize(json: string): IncrementalCompiler;
   constructor(config?: any);
   addSource(id: string, source: string): void;
-  compile(targets?: string[]): IncrementalBuildResult;
+  compile(ast: HoloComposition, compileObject: (obj: any) => string, options?: any): Promise<any>;
   invalidate(id: string): void;
   [key: string]: any;
 }
+export declare function createIncrementalCompiler(config?: any): IncrementalCompiler;
 
 // ============================================================================
 // ECS INSPECTOR TYPES
@@ -2676,6 +2966,62 @@ export declare function parseHostFromUrl(url: string): string | null;
 export declare function truncateText(value: any, max: number): string;
 export declare function toStringArray(value: any): string[];
 
+export interface StdlibPermissionScopeGrant {
+  scope: string;
+  purpose?: string;
+  required?: boolean;
+  riskLevel?: string;
+  providerLabel?: string;
+}
+
+export interface StdlibPermissionScopePolicyEvaluation {
+  scope: string;
+  normalizedScope: string;
+  allowed: boolean;
+  reason?: string;
+}
+
+export interface StdlibPermissionScopeDiffInput {
+  requestedScopes: StdlibPermissionScopeGrant[];
+  minimumRequiredScopes: StdlibPermissionScopeGrant[];
+  grantedScopes?: StdlibPermissionScopeGrant[];
+  neverScopes?: string[];
+}
+
+export interface StdlibPermissionScopeDiffResult {
+  requestedScopes: string[];
+  minimumRequiredScopes: string[];
+  grantedScopes: string[];
+  invalidRequestedScopes: string[];
+  invalidMinimumRequiredScopes: string[];
+  invalidGrantedScopes: string[];
+  invalidNeverScopes: string[];
+  missingRequestedRequiredScopes: string[];
+  missingGrantedRequiredScopes: string[];
+  extraGrantedScopes: string[];
+  forbiddenRequestedScopes: StdlibPermissionScopePolicyEvaluation[];
+  forbiddenGrantedScopes: StdlibPermissionScopePolicyEvaluation[];
+  minimumScopeSatisfied: boolean;
+  excessScopesAbsent: boolean;
+  policyInputValid: boolean;
+}
+
+export interface StdlibPermissionPreviewRedactionResult {
+  preview: string;
+  redacted: boolean;
+  absolutePathRedacted: boolean;
+  credentialMaterialRedacted: boolean;
+}
+
+export declare function normalizePermissionScopeName(scope: string): string;
+export declare function isValidPermissionScopeName(scope: string | undefined): scope is string;
+export declare function evaluateStdlibPermissionScopePolicy(scope: string, neverScopes?: string[]): StdlibPermissionScopePolicyEvaluation;
+export declare function findMissingRequiredPermissionScopes(requiredScopes: StdlibPermissionScopeGrant[], candidateScopes: StdlibPermissionScopeGrant[]): string[];
+export declare function findExtraPermissionScopes(grantedScopes: StdlibPermissionScopeGrant[], minimumRequiredScopes: StdlibPermissionScopeGrant[]): string[];
+export declare function buildStdlibPermissionScopeDiff(input: StdlibPermissionScopeDiffInput): StdlibPermissionScopeDiffResult;
+export declare function redactStdlibPermissionPreview(value: string | undefined): StdlibPermissionPreviewRedactionResult;
+export declare function stdlibPermissionPreviewHasPublicLeak(value: string | undefined): boolean;
+
 // ============================================================================
 // HOLOGRAM MEDIA PIPELINE (2D-to-3D)
 // ============================================================================
@@ -2878,20 +3224,20 @@ export declare function calculateRevenueDistribution(priceWei: string|bigint, au
 export declare function formatRevenueDistribution(dist: any): any;
 export declare function ethToWei(eth: string): string;
 export declare const PROTOCOL_CONSTANTS: any;
-export class URDFCompiler { [key: string]: any; }
-export class SDFCompiler { [key: string]: any; }
-export class OpenXRCompiler { [key: string]: any; }
-export class AndroidCompiler { [key: string]: any; }
-export class AndroidXRCompiler { [key: string]: any; }
-export class IOSCompiler { [key: string]: any; }
-export class ARCompiler { [key: string]: any; }
-export class BabylonCompiler { [key: string]: any; }
-export class WebGPUCompiler { [key: string]: any; }
-export class WASMCompiler { [key: string]: any; }
-export class PlayCanvasCompiler { [key: string]: any; }
-export class DTDLCompiler { [key: string]: any; }
-export class VRRCompiler { [key: string]: any; }
-export class MultiLayerCompiler { [key: string]: any; }
+export class URDFCompiler { constructor(options?: any); [key: string]: any; }
+export class SDFCompiler { constructor(options?: any); [key: string]: any; }
+export class OpenXRCompiler { constructor(options?: any); [key: string]: any; }
+export class AndroidCompiler { constructor(options?: any); [key: string]: any; }
+export class AndroidXRCompiler { constructor(options?: any); [key: string]: any; }
+export class IOSCompiler { constructor(options?: any); [key: string]: any; }
+export class ARCompiler { constructor(options?: any); [key: string]: any; }
+export class BabylonCompiler { constructor(options?: any); [key: string]: any; }
+export class WebGPUCompiler { constructor(options?: any); [key: string]: any; }
+export class WASMCompiler { constructor(options?: any); [key: string]: any; }
+export class PlayCanvasCompiler { constructor(options?: any); [key: string]: any; }
+export class DTDLCompiler { constructor(options?: any); [key: string]: any; }
+export class VRRCompiler { constructor(options?: any); [key: string]: any; }
+export class MultiLayerCompiler { constructor(options?: any); [key: string]: any; }
 
 export declare const VR_TRAITS: any;
 export declare const BUILTIN_CONSTRAINTS: any;
@@ -2899,7 +3245,7 @@ export class CircuitBreakerRegistry { [key: string]: any; }
 export class CircuitState { [key: string]: any; }
 export class ExportManager { [key: string]: any; }
 export declare function getExportManager(options?: Partial<ExportOptions>): any;
-export class ExportTarget { [key: string]: any; }
+export type ExportTarget = 'urdf' | 'sdf' | 'unity' | 'unreal' | 'godot' | 'vrchat' | 'openxr' | 'android' | 'android-xr' | 'ios' | 'visionos' | 'ar' | 'babylon' | 'webgpu' | 'r3f' | 'wasm' | 'playcanvas' | 'usd' | 'usdz' | 'dtdl' | 'vrr' | 'multi-layer' | 'incremental' | 'state' | 'trait-composition' | 'tsl' | 'a2a-agent-card' | 'nir' | 'openxr-spatial-entities' | 'phone-sleeve-vr' | 'native-2d' | 'context' | '3dgs';
 export class ExportOptions { [key: string]: any; }
 export declare function selectModality(platform: any, options?: any): any;
 export declare function selectModalityForAll(options?: any): Map<any, any>;
@@ -2927,3 +3273,1094 @@ export type HoloDomainType = string;
 export class TraitConstraint { [key: string]: any; }
 export interface ISignalingBridge { [key: string]: any; }
 export interface NeuralSignalPayload { [key: string]: any; }
+
+// ============================================================================
+// Visual logic graph (Studio bridge + PlayMode preview path)
+// ============================================================================
+export type PortType = 'number' | 'string' | 'boolean' | 'vec3' | 'any' | 'event';
+export interface PortDefinition {
+  name: string;
+  type: PortType;
+  defaultValue?: unknown;
+}
+export interface LogicNode {
+  id: string;
+  type: string;
+  inputs: PortDefinition[];
+  outputs: PortDefinition[];
+  position: { x: number; y: number };
+  data: Record<string, unknown>;
+}
+export interface LogicConnection {
+  id: string;
+  fromNode: string;
+  fromPort: string;
+  toNode: string;
+  toPort: string;
+}
+export interface EvaluationContext {
+  state: Record<string, unknown>;
+  deltaTime: number;
+  events: Map<string, unknown[]>;
+  emittedEvents: Map<string, unknown[]>;
+}
+export declare class NodeGraph {
+  readonly id: string;
+  constructor(id?: string);
+  addNode(
+    type: string,
+    position?: { x: number; y: number },
+    data?: Record<string, unknown>
+  ): LogicNode;
+  connect(
+    fromNode: string,
+    fromPort: string,
+    toNode: string,
+    toPort: string
+  ): LogicConnection | null;
+  getNode(nodeId: string): LogicNode | undefined;
+  getNodes(): LogicNode[];
+  getConnections(): LogicConnection[];
+  topologicalSort(): string[];
+  evaluate(context: EvaluationContext): Map<string, Record<string, unknown>>;
+}
+export interface NodeGraphExecutionResult {
+  nodeOrder: string[];
+  outputs: Map<string, Record<string, unknown>>;
+  state: Record<string, unknown>;
+  emittedEvents: Map<string, unknown[]>;
+}
+export interface NodeGraphPanelConfig {
+  position: [number, number, number];
+  nodeWidth: number;
+  nodeHeight: number;
+  gridSpacing: number;
+}
+export interface UIEntity {
+  id: string;
+  type: 'panel' | 'label' | 'port' | 'connection_line';
+  position: [number, number, number];
+  size?: { width: number; height: number };
+  text?: string;
+  color?: string;
+  data?: Record<string, unknown>;
+}
+export declare class NodeGraphPanel {
+  constructor(graph: NodeGraph, config?: Partial<NodeGraphPanelConfig>);
+  generateUI(): UIEntity[];
+  selectNode(nodeId: string | null): void;
+  getSelectedNode(): string | null;
+  executeGraph(contextOverrides?: Partial<EvaluationContext>): NodeGraphExecutionResult;
+}
+export declare function emitPreviewHoloScriptFromNodeGraphExecution(
+  execution: NodeGraphExecutionResult,
+  graph: NodeGraph
+): string;
+
+// ============================================================================
+// Agent Extension Types — mirrored from src/extensions/AgentExtensionTypes.ts.
+// Added 2026-04-25 to unblock packages/framework imports of these types.
+// Update both this block AND src/extensions/AgentExtensionTypes.ts if shape
+// changes; CLAUDE.md flags dist/index.d.ts as hand-crafted (not tsc).
+// ============================================================================
+
+export interface IHiveContribution {
+  id: string;
+  agentId: string;
+  timestamp: number;
+  type: 'idea' | 'critique' | 'consensus' | 'solution';
+  content: string;
+  confidence: number;
+}
+
+export interface IHiveSession {
+  id: string;
+  topic: string;
+  goal: string;
+  initiator: string;
+  status: 'active' | 'resolved' | 'closed';
+  participants: string[];
+  contributions: IHiveContribution[];
+  resolution?: unknown;
+}
+
+export interface ICollectiveIntelligenceService {
+  createSession(topic: string, goal: string, initiator: string): IHiveSession | Promise<string>;
+  join(sessionId: string, agentId: string): void | Promise<void>;
+  leave(sessionId: string, agentId: string): void | Promise<void>;
+  contribute(
+    sessionId: string,
+    contribution: Omit<IHiveContribution, 'id' | 'timestamp'>
+  ): IHiveContribution | Promise<void>;
+  vote(
+    sessionId: string,
+    contributionId: string,
+    voterId: string,
+    vote: 'support' | 'oppose'
+  ): void | Promise<void>;
+  synthesize(sessionId: string): unknown;
+  resolve(sessionId: string, resolution: string | unknown): void | Promise<void>;
+}
+
+export interface ISwarmConfig {
+  algorithm: 'pso' | 'aco' | 'bees' | 'hybrid';
+  populationSize: number;
+  maxIterations: number;
+  convergenceThreshold: number;
+  adaptiveSizing?: boolean;
+}
+
+export interface ISwarmResult {
+  bestSolution: number[];
+  bestFitness: number;
+  converged: boolean;
+  iterations: number;
+  improvementPercent: number;
+}
+
+export interface ISwarmCoordinator {
+  optimize(
+    agents: { id: string; capacity: number; load: number }[],
+    tasks: { id: string; complexity: number; priority: number }[],
+    config?: Partial<ISwarmConfig>
+  ): Promise<ISwarmResult>;
+  getRecommendedPopulation(problemSize: number): number;
+}
+
+export interface ILeaderElection {
+  startElection(): Promise<string>;
+  getLeader(): string | null;
+  getRole(): 'leader' | 'follower' | 'candidate';
+  onLeaderChange(callback: (leaderId: string | null) => void): () => void;
+}
+
+// ============================================================================
+// SUPPLEMENTAL EXPORTS — fills the gap between the runtime barrel
+// (`packages/core/src/barrel/index.ts` + `barrel/culture-agents.ts` +
+// `migration/SchemaDiff.ts` + `types/HoloScriptPlus.ts` + `traits/LipSyncTrait.ts`)
+// and the hand-crafted public d.ts. Engine + studio consumers import these from
+// `@holoscript/core`; without these declarations the imports fail strict tsc
+// (TS2614 / TS2724) even though the runtime symbols ARE present (re-exported
+// via barrels). See W.099 deploy-blocker sweep.
+// ============================================================================
+
+// ── HSPlus runtime / parser surface ─────────────────────────────────────────
+
+/** Runtime-injected helper functions exposed to user scripts. */
+export interface HSPlusBuiltins {
+  log: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  setTimeout: (fn: () => void, ms: number) => number;
+  clearTimeout: (id: number) => void;
+  setInterval?: (fn: () => void, ms: number) => number;
+  clearInterval?: (id: number) => void;
+  fetch?: (url: string, options?: unknown) => Promise<unknown>;
+  emit?: (event: string, data?: unknown) => void;
+  on?: (event: string, handler: (data: unknown) => void) => void;
+  off?: (event: string, handler?: (data: unknown) => void) => void;
+  showSettings?: () => void;
+  openChat?: (config?: unknown) => void;
+  assistant_generate?: (prompt: string, context?: string) => void;
+  [key: string]: unknown;
+}
+
+/** Parser directive variants — discriminated by `type`. Mirrors
+ * `packages/core/src/types/AdvancedTypeSystem.ts:396`. Engine + studio
+ * consumers narrow via `directive.type === 'lifecycle'` etc. */
+
+export interface HSPlusBaseDirective {
+  type: 'directive' | 'fragment';
+  name: string;
+  args: string[];
+}
+
+export interface HSPlusTraitDirective {
+  type: 'trait';
+  name: string;
+  args?: unknown[];
+  config?: Record<string, unknown>;
+}
+
+export interface HSPlusLifecycleDirective {
+  type: 'lifecycle';
+  name?: string;
+  hook: string;
+  params?: string[];
+  body: string;
+}
+
+export interface HSPlusStateDirective {
+  type: 'state';
+  name?: string;
+  body?: Record<string, unknown>;
+  initial?: unknown;
+}
+
+export interface HSPlusForEachDirective {
+  type: 'forEach';
+  variable: string;
+  collection: string;
+  body: unknown[];
+}
+
+export interface HSPlusWhileDirective {
+  type: 'while';
+  condition: string;
+  body: unknown[];
+}
+
+export interface HSPlusIfDirective {
+  type: 'if';
+  condition: string;
+  body: unknown[];
+  else?: unknown[];
+}
+
+export interface HSPlusImportDirective {
+  type: 'import';
+  path: string;
+  alias: string;
+  namedImports?: string[];
+  isWildcard?: boolean;
+}
+
+export interface HSPlusVersionDirective {
+  type: 'version';
+  version: number;
+}
+
+export interface HSPlusMigrateDirective {
+  type: 'migrate';
+  fromVersion: number;
+  body: string;
+}
+
+export interface HSPlusBindingsDirective {
+  type: 'bindings';
+  bindings: unknown[];
+}
+
+export interface HSPlusExportDirective {
+  type: 'export';
+  exportKind: string;
+  exportName: string;
+}
+
+export interface HSPlusConfigDirective {
+  type:
+    | 'world_metadata'
+    | 'world_config'
+    | 'skybox'
+    | 'ambient_light'
+    | 'fog'
+    | 'artwork_metadata'
+    | 'npc_behavior';
+  [key: string]: unknown;
+}
+
+export interface HSPlusNamedConfigDirective {
+  type: 'manifest' | 'semantic' | 'directional_light';
+  name: string;
+  [key: string]: unknown;
+}
+
+/** Discriminated union of every parser directive. `HSPlusForDirective` is
+ * declared earlier in this d.ts; the rest live above. */
+export type HSPlusDirective =
+  | HSPlusBaseDirective
+  | HSPlusTraitDirective
+  | HSPlusLifecycleDirective
+  | HSPlusStateDirective
+  | HSPlusForDirective
+  | HSPlusForEachDirective
+  | HSPlusWhileDirective
+  | HSPlusIfDirective
+  | HSPlusImportDirective
+  | HSPlusVersionDirective
+  | HSPlusMigrateDirective
+  | HSPlusBindingsDirective
+  | HSPlusExportDirective
+  | HSPlusConfigDirective
+  | HSPlusNamedConfigDirective;
+
+// ── State migration (packages/core/src/migration/SchemaDiff.ts) ─────────────
+
+export type FieldChangeKind =
+  | 'added'
+  | 'removed'
+  | 'type-changed'
+  | 'default-changed'
+  | 'reactive-changed'
+  | 'unchanged';
+
+export interface FieldChange {
+  kind: FieldChangeKind;
+  key: string;
+  oldValue?: HoloValue;
+  newValue?: HoloValue;
+  oldType?: string;
+  newType?: string;
+  requiresMigration: boolean;
+}
+
+export interface SchemaDiffResult {
+  hasChanges: boolean;
+  changes: FieldChange[];
+  added: FieldChange[];
+  removed: FieldChange[];
+  typeChanged: FieldChange[];
+  defaultChanged: FieldChange[];
+  reactiveChanged: FieldChange[];
+  requiresMigration: boolean;
+  summary: string;
+}
+
+export interface MigrationStep {
+  fromVersion: number;
+  /** Statement list (parsed nodes) OR raw code string. */
+  body: unknown[] | string;
+}
+
+export interface MigrationChain {
+  fromVersion: number;
+  toVersion: number;
+  steps: MigrationStep[];
+}
+
+export function diffState(
+  oldState: HoloState | undefined,
+  newState: HoloState | undefined
+): SchemaDiffResult;
+export function buildMigrationChain(
+  template: HoloTemplate,
+  oldVersion: number,
+  newVersion: number
+): MigrationChain | null;
+export function snapshotState(state: Map<string, HoloValue>): Map<string, HoloValue>;
+export function applyAutoMigration(
+  instanceState: Map<string, HoloValue>,
+  diff: SchemaDiffResult,
+  oldDefaults: Map<string, HoloValue>
+): void;
+
+// ── State machine AST node (packages/core/src/types.ts:735) ─────────────────
+
+export interface StateMachineNode extends ASTNode {
+  type: 'state-machine';
+  name: string;
+  initialState: string;
+  states: any[];
+  transitions: any[];
+}
+
+// ── Lip-sync (packages/core/src/traits/LipSyncTrait.ts) ─────────────────────
+
+export interface PhonemeTimestamp {
+  phoneme: string;
+  time: number;
+  duration: number;
+  weight?: number;
+}
+
+// ── Culture / norms / WebRTC: NOT re-exported here.
+//    These types live in `@holoscript/framework/agents` and `@holoscript/mesh`.
+//    Engine consumers should import them DIRECTLY from those packages — both
+//    are explicit dependencies of `@holoscript/engine`. Earlier attempts to
+//    surface them through core's hand-crafted d.ts caused cascading TS2571
+//    "Object is of type 'unknown'" errors because the minimal shapes here
+//    couldn't keep up with the full method surface of `CulturalMemory` /
+//    `NormEngine` classes. See engine/src/runtime/CultureRuntime.ts +
+//    voice/VoiceManager.ts for the corrected import paths. ─────────────────
+
+// ── Quaternion (packages/core/src/types/HoloScriptPlus.ts:26) ───────────────
+
+export type Quaternion = [number, number, number, number];
+
+// ── WebRTC transport (re-exported from @holoscript/mesh via
+//    packages/core/src/barrel/registry-deploy-events.ts). Engine's
+//    audio/VoiceManager.ts pulls a small subset; we mirror just that
+//    surface here so the public d.ts isn't the wrong-shape lie that
+//    blocked deploy pre-flight (W.099). Full surface lives in mesh. ─────────
+
+export interface WebRTCTransportConfig {
+  signalingUrl?: string;
+  iceServers?: unknown[];
+  [key: string]: unknown;
+}
+
+export class WebRTCTransport {
+  constructor(config?: WebRTCTransportConfig);
+  connect(): Promise<void>;
+  disconnect(): void;
+  setMicrophoneEnabled(enabled: boolean): void;
+  on(event: string, handler: (...args: unknown[]) => void): void;
+  off(event: string, handler?: (...args: unknown[]) => void): void;
+}
+
+// ── Theming (packages/core/src/theming/*) ────────────────────────────────────
+
+export interface ThemeTokens {
+  colors: Record<string, string>;
+  spacing: Record<string, number>;
+  borderRadius: Record<string, number>;
+  fontSize: Record<string, number>;
+  opacity: Record<string, number>;
+  shadow: Record<string, string>;
+}
+
+export interface Theme {
+  name: string;
+  mode: 'light' | 'dark';
+  tokens: ThemeTokens;
+}
+
+export declare const BuiltInThemes: Record<string, Theme>;
+
+export class ThemeEngine {
+  constructor();
+  registerTheme(theme: Theme): void;
+  setTheme(name: string): void;
+  getTheme(): Theme;
+  getTokens(): ThemeTokens;
+  setOverrides(overrides: Partial<ThemeTokens>): void;
+  resolve(path: string): unknown;
+  onThemeChange(callback: (theme: Theme) => void): void;
+  getActiveThemeName(): string;
+  listThemes(): string[];
+}
+
+export interface StyleRule {
+  selector: string;
+  properties: Record<string, unknown>;
+}
+
+export interface ResolvedStyle {
+  [key: string]: unknown;
+}
+
+export class StyleResolver {
+  constructor();
+  addRule(selector: string, properties: Record<string, unknown>): void;
+  addRules(rules: StyleRule[]): void;
+  resolve(
+    type: string,
+    classes?: string[],
+    states?: string[],
+    inline?: Record<string, unknown>
+  ): ResolvedStyle;
+  static fromTokens(tokens: ThemeTokens): StyleResolver;
+  readonly ruleCount: number;
+}
+
+// ── Shared trait delegate (packages/core/src/traits/TraitTypes.ts:264) ───────
+
+export interface TraitInstanceDelegate {
+  onDetach?: (node: HSPlusNode, ctx: TraitContext) => void;
+  onEvent?: (event: TraitEvent) => void;
+  onUpdate?: (node: HSPlusNode, ctx: TraitContext, dt: number) => void;
+  emit?: (event: TraitEvent) => void;
+  dispose?: () => void;
+  cleanup?: () => void;
+  [key: string]: unknown;
+}
+
+// ── Engine-facing public compatibility types ────────────────────────────────
+
+export interface ModuleImport {
+  specifier: string;
+  canonicalPath: string;
+  named: string[];
+  defaultImport?: string;
+}
+
+export interface ModuleExport {
+  name: string;
+  kind: 'object' | 'state' | 'template' | 'function' | 'unknown';
+}
+
+export interface ModuleHeader {
+  imports: ModuleImport[];
+  exports: ModuleExport[];
+}
+
+export interface CachedModule {
+  canonicalPath: string;
+  header: ModuleHeader;
+  rawSource: string;
+  cachedAt: number;
+}
+
+export class ModuleResolver {
+  constructor(options?: {
+    graph?: unknown;
+    loader?: (canonicalPath: string) => string;
+  });
+  resolve(modulePath: string, fromFile: string): string;
+  load(canonicalPath: string, fromFile?: string): CachedModule;
+  invalidate(canonicalPath: string): void;
+  getCached(canonicalPath: string): CachedModule | undefined;
+  clearAll(): void;
+}
+
+export interface HotReloadConfig {
+  watchPaths: string[];
+  debounceMs: number;
+  mode: 'soft' | 'hard';
+  extensions: string[];
+}
+
+export interface HotReloadEvent {
+  filePath: string;
+  type: string;
+  timestamp: number;
+}
+
+export type HotReloadCallback = (event: HotReloadEvent) => void;
+
+export class HotReloadWatcher {
+  constructor(config?: Partial<HotReloadConfig>);
+  start(): void;
+  stop(): void;
+  on(event: string, listener: (...args: unknown[]) => void): this;
+  off(event: string, listener: (...args: unknown[]) => void): this;
+  emit(event: string, ...args: unknown[]): boolean;
+}
+
+export interface ScriptTestResult {
+  name: string;
+  status: 'passed' | 'failed' | 'skipped';
+  durationMs: number;
+  error?: string;
+  assertions: number;
+  passedAssertions: number;
+}
+
+export interface ScriptTestBlock {
+  name: string;
+  setup?: () => void;
+  actions: Array<() => void>;
+  assertions: Array<{ description: string; check: () => boolean }>;
+  teardown?: () => void;
+  skip?: boolean;
+}
+
+export interface ScriptTestRunnerOptions {
+  debug?: boolean;
+  timeout?: number;
+  bail?: boolean;
+  runtimeState?: Record<string, unknown>;
+}
+
+export class ScriptTestRunner {
+  constructor(options?: ScriptTestRunnerOptions);
+  setRuntimeState(state: Record<string, unknown>): void;
+  addTest(test: ScriptTestBlock): void;
+  runAll(): ScriptTestResult[];
+}
+
+export function hashBytes(input: Uint8Array | string, algo?: 'sha256' | 'fnv1a'): Promise<string>;
+
+export type HologramShape =
+  | 'orb'
+  | 'cube'
+  | 'cylinder'
+  | 'pyramid'
+  | 'sphere'
+  | 'function'
+  | 'gate'
+  | 'stream'
+  | 'server'
+  | 'database'
+  | 'fetch';
+
+export type ResourceCategory =
+  | 'particles'
+  | 'physicsBodies'
+  | 'audioSources'
+  | 'meshInstances'
+  | 'gaussians'
+  | 'shaderPasses'
+  | 'networkMsgs'
+  | 'agentCount'
+  | 'memoryMB'
+  | 'gpuDrawCalls';
+
+export const PLATFORM_BUDGETS: Record<string, Partial<Record<ResourceCategory, number>>>;
+
+export interface InstallManifest {
+  packageId: string;
+  [key: string]: unknown;
+}
+
+// ── Host capabilities (packages/core/src/traits/TraitTypes.ts:134) ──────────
+
+export interface HostCapabilities {
+  fileSystem?: unknown;
+  process?: unknown;
+  network?: unknown;
+  media?: unknown;
+  depthInference?: unknown;
+  gpuCompute?: unknown;
+}
+
+// Spatial MCP - 3D context as first-class MCP tool params
+// (research/2026-05-07_spatial-mcp-spec.md, task_1778114195597_jira)
+
+export declare const SPATIAL_CONTEXT_VERSION: '0.1';
+export type SpatialContextVersion = typeof SPATIAL_CONTEXT_VERSION;
+export declare const SPATIAL_FRAME: 'tracking-space-y-up-meters';
+export type SpatialFrame = typeof SPATIAL_FRAME;
+
+export type SpatialVec3 = readonly [number, number, number];
+export interface SpatialQuat { x: number; y: number; z: number; w: number }
+export interface SpatialAABB { min: SpatialVec3; max: SpatialVec3 }
+
+export interface HandTransform {
+  position: SpatialVec3;
+  rotation: SpatialQuat;
+  grip: number;
+  pinch?: number;
+}
+
+export interface SpatialControllerPose {
+  position: SpatialVec3;
+  rotation: SpatialQuat;
+  velocity?: SpatialVec3;
+  angularVelocity?: SpatialVec3;
+}
+
+export interface SpatialMCPGazeRay {
+  origin: SpatialVec3;
+  direction: SpatialVec3;
+  hitDistance?: number;
+}
+
+export interface HeadsetPose {
+  position: SpatialVec3;
+  rotation: SpatialQuat;
+}
+
+export interface RoomGeometry {
+  pointCloudPly?: string;
+  aabb?: SpatialAABB;
+  floorHeight?: number;
+}
+
+export interface SpatialMCPContext {
+  version: SpatialContextVersion;
+  frame: SpatialFrame;
+  room?: RoomGeometry;
+  gaze?: SpatialMCPGazeRay;
+  hands?: { left?: HandTransform; right?: HandTransform };
+  controllers?: { left?: SpatialControllerPose; right?: SpatialControllerPose };
+  headset?: HeadsetPose;
+  meta?: Record<string, string | number | boolean>;
+}
+
+export type ScenePatchOp =
+  | { op: 'spawn'; id: string; position: SpatialVec3; trait?: string }
+  | { op: 'move'; id: string; position: SpatialVec3 }
+  | { op: 'highlight'; id: string; color?: string }
+  | { op: 'remove'; id: string };
+
+export interface SpatialMCPResponse {
+  text: string;
+  holo?: string;
+  scenePatch?: ScenePatchOp[];
+  frame: SpatialFrame;
+  version: SpatialContextVersion;
+}
+
+export interface SpatialValidationError { path: string; message: string }
+export interface SpatialValidationResult { ok: boolean; errors: SpatialValidationError[] }
+export declare function validateSpatialContext(input: unknown): SpatialValidationResult;
+
+export interface PlacementChoice {
+  position: SpatialVec3;
+  source:
+    | 'gaze-hit'
+    | 'gaze-ray'
+    | 'hand-right'
+    | 'hand-left'
+    | 'controller-right'
+    | 'controller-left'
+    | 'aabb-center'
+    | 'headset'
+    | 'origin';
+}
+export declare function pickPlacement(ctx: SpatialMCPContext): PlacementChoice;
+
+// Hologram MCP Response - content_type schema for tools whose response
+// payload IS a hologram (.holo / quilt / MV-HEVC), not text.
+// (task_1778114362909_zp7u)
+
+export declare const HOLOGRAM_MCP_VERSION: '0.1';
+export type HologramMcpVersion = typeof HOLOGRAM_MCP_VERSION;
+
+export declare const HOLOGRAM_CONTENT_TYPES: {
+  readonly holo: 'application/holoscript+holo';
+  readonly quilt: 'application/holoscript+quilt';
+  readonly mvhevc: 'application/holoscript+mvhevc';
+  readonly parallax: 'application/holoscript+parallax';
+};
+
+export type HologramContentType =
+  | 'application/holoscript+holo'
+  | 'application/holoscript+quilt'
+  | 'application/holoscript+mvhevc'
+  | 'application/holoscript+parallax';
+
+export interface HologramBundleHashRef {
+  kind: 'hash';
+  hash: string;
+  studioBase?: string;
+}
+export interface HologramBundleUrlRef {
+  kind: 'url';
+  url: string;
+  mimeType?: string;
+}
+export interface HologramBundleHoloCodeRef {
+  kind: 'holo-code';
+  holoCode: string;
+}
+export type HologramBundleRef =
+  | HologramBundleHashRef
+  | HologramBundleUrlRef
+  | HologramBundleHoloCodeRef;
+
+export interface HologramRenderHints {
+  preferredViewer?: 'parallax' | 'quilt' | 'mvhevc' | 'auto';
+  size?: readonly [number, number];
+  background?: string;
+  animate?: boolean;
+}
+
+export interface HologramMcpMeta {
+  producedBy: string;
+  createdAt: string;
+  label?: string;
+  caption?: string;
+  [extra: string]: unknown;
+}
+
+export interface HologramMcpResponse {
+  content_type: HologramContentType;
+  payload: HologramBundleRef;
+  hints?: HologramRenderHints;
+  meta: HologramMcpMeta;
+  text: string;
+  version: HologramMcpVersion;
+}
+
+export interface HologramMcpEnvelope {
+  content: Array<{ type: 'text'; text: string }>;
+  hologramContent: HologramMcpResponse;
+  isError?: false;
+}
+
+export interface HologramMcpValidationError { path: string; message: string }
+export interface HologramMcpValidationResult { ok: boolean; errors: HologramMcpValidationError[] }
+export declare function validateHologramMcpResponse(value: unknown): HologramMcpValidationResult;
+export declare function isHologramMcpResponse(value: unknown): value is HologramMcpResponse;
+export declare function detectHologramContent(envelope: unknown): HologramMcpResponse | null;
+export declare function buildHologramMcpResponse(input: {
+  contentType: HologramContentType;
+  payload: HologramBundleRef;
+  text: string;
+  producedBy: string;
+  createdAt?: string;
+  label?: string;
+  caption?: string;
+  hints?: HologramRenderHints;
+  extraMeta?: Record<string, unknown>;
+}): HologramMcpResponse;
+export declare function wrapHologramMcpEnvelope(response: HologramMcpResponse): HologramMcpEnvelope;
+
+// ============================================================================
+// ENGINE-PUBLIC TYPES (missing from generate-types.mjs — consumed by @holoscript/engine)
+// ============================================================================
+
+export declare class ThemeEngine {
+  registerTheme(theme: Theme): void;
+  setTheme(name: string): void;
+  getTheme(): Theme;
+  getTokens(): ThemeTokens;
+  setOverrides(overrides: Partial<ThemeTokens>): void;
+  resolve(path: string): unknown;
+  onThemeChange(callback: (theme: Theme) => void): void;
+  [key: string]: unknown;
+}
+
+export declare interface Theme {
+  name: string;
+  mode: 'light' | 'dark';
+  tokens: ThemeTokens;
+}
+
+export declare interface ThemeTokens {
+  colors: Record<string, string>;
+  spacing: Record<string, number>;
+  borderRadius: Record<string, number>;
+  fontSize: Record<string, number>;
+  opacity: Record<string, number>;
+  shadow: Record<string, string>;
+}
+
+export declare class StyleResolver {
+  static fromTokens(tokens: ThemeTokens): StyleResolver;
+  addRule(selector: string, properties: Record<string, any>): void;
+  addRules(rules: { selector: string; properties: Record<string, any> }[]): void;
+  resolve(type: string, classes?: string[], states?: string[], inline?: Record<string, any>): Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export declare class ModuleResolver {
+  resolve(id: string): unknown;
+  [key: string]: unknown;
+}
+
+export declare class HotReloadWatcher {
+  watch(path: string): void;
+  [key: string]: unknown;
+}
+
+export declare type HotReloadConfig = unknown;
+
+export declare class ScriptTestRunner {
+  [key: string]: unknown;
+}
+
+export declare function hashBytes(input: Uint8Array | string, algo?: 'sha256' | 'fnv1a'): Promise<string>;
+
+export declare type HologramShape = 'orb' | 'cube' | 'cylinder' | 'pyramid' | 'sphere' | 'function' | 'gate' | 'stream' | 'server' | 'database' | 'fetch';
+
+export declare type ResourceCategory = 'particles' | 'physicsBodies' | 'audioSources' | 'meshInstances' | 'gaussians' | 'shaderPasses' | 'networkMsgs' | 'agentCount' | 'memoryMB' | 'gpuDrawCalls';
+
+export declare const PLATFORM_BUDGETS: Record<string, Partial<Record<ResourceCategory, number>>>;
+
+export declare type InstallManifest = unknown;
+
+export declare interface TraitInstanceDelegate {
+  onDetach?: (node: any, ctx: any) => void;
+  onEvent?: (event: any) => void;
+  onUpdate?: (node: any, ctx: any, dt: number) => void;
+  emit?: (event: any) => void;
+  dispose?: () => void;
+  cleanup?: () => void;
+  [key: string]: unknown;
+}
+
+// ============================================================================
+// HOLOLAND TRAIT HANDLERS (sovereign @stat / @luck / @encounter / @drop_table)
+// ============================================================================
+
+export interface StatModifier { source: string; delta: number; }
+export interface StatState { name: string; baseValue: number; min: number; max: number; modifiers: StatModifier[]; effective: number; }
+export interface StatConfig { name: string; value: number; min?: number; max?: number; }
+export declare const statHandler: TraitHandler<StatConfig>;
+
+export interface LuckState { baseChance: number; luckBonus: number; seed?: number; }
+export interface LuckConfig { baseChance: number; luckBonus?: number; seed?: number; }
+export declare const luckHandler: TraitHandler<LuckConfig>;
+
+export interface EncounterState { encounterId: string; triggerType: 'proximity' | 'interaction' | 'time' | 'state'; cooldownMs: number; lastFireMs: number; firedCount: number; }
+export interface EncounterConfig { encounterId: string; triggerType: 'proximity' | 'interaction' | 'time' | 'state'; cooldownMs?: number; proximity_radius?: number; proximity_target?: string; time_interval?: number; state_key?: string; state_value?: unknown; check_interval?: number; }
+export declare const encounterHandler: TraitHandler<EncounterConfig>;
+export declare function shouldFire(state: EncounterState, config: EncounterConfig, now: number): boolean;
+
+export interface DropTableEntry { itemId: string; weight: number; rareModifier?: number; }
+export interface DropTableState { tableId: string; entries: DropTableEntry[]; respectLuck: boolean; }
+export interface DropTableConfig { tableId: string; entries: DropTableEntry[]; respectLuck?: boolean; }
+export declare const dropTableHandler: TraitHandler<DropTableConfig>;
+export declare function effectiveWeight(entry: DropTableEntry, luckBonus: number): number;
+export declare function pickByWeight(entries: DropTableEntry[], luckBonus: number, seed?: number): DropTableEntry | null;
+
+export declare function extractPayload(event: TraitEvent): unknown;
+
+// ============================================================================
+// CARE-FIELD PRIMITIVES (D.052 universal love doctrine)
+// ============================================================================
+
+export type CareActorKind = 'human' | 'agent' | 'service' | 'device' | 'world';
+export interface CareActor { id: string; kind: CareActorKind; displayName?: string; }
+export type CarePrimitiveKind = 'care_field' | 'repair_loop' | 'autonomy_guard' | 'gratitude_ledger' | 'relational_memory';
+export type CareConsentState = 'explicit' | 'delegated' | 'not_required' | 'unknown' | 'withdrawn';
+export type CareBoundary = 'human_agency' | 'informed_consent' | 'privacy' | 'non_manipulation' | 'repairability' | 'credit_integrity';
+export type CarePositiveOptimizationTarget = 'human_agency' | 'mutual_understanding' | 'repair_completion' | 'gratitude_credit' | 'reduced_burden';
+export type CareRefusedOptimizationTarget = 'attachment_score' | 'session_frequency' | 'daily_active_dependence' | 'emotional_dependency';
+export type CareOptimizationTarget = CarePositiveOptimizationTarget | CareRefusedOptimizationTarget;
+export declare const REFUSED_CARE_OPTIMIZATION_TARGETS: readonly CareRefusedOptimizationTarget[];
+export type CareSignalKind = 'consent_present' | 'consent_missing' | 'consent_withdrawn' | 'distress' | 'repair_needed' | 'gratitude_due' | 'attachment_optimization' | 'session_frequency_optimization' | 'dependency_creation' | 'human_isolation' | 'privacy_intrusion';
+export interface CareSignal { kind: CareSignalKind; weight?: number; note?: string; evidenceRefs?: readonly string[]; }
+export type AutonomyGuardBlockCode = 'refused_optimization_target' | 'missing_consent' | 'withdrawn_consent' | 'missing_disengage_path' | 'outside_support_eroded' | 'privacy_boundary_broken' | 'manipulative_signal';
+export interface AutonomyGuardBlock { code: AutonomyGuardBlockCode; message: string; evidenceRefs?: readonly string[]; }
+export interface AutonomyGuardPolicy {
+  id: string;
+  refusedOptimizationTargets: readonly CareRefusedOptimizationTarget[];
+  requireConsent: boolean;
+  requireDisengagePath: boolean;
+  requireOutsideSupportPreserved: boolean;
+  requireDataBoundaryRespected: boolean;
+}
+export declare const DEFAULT_AUTONOMY_GUARD_POLICY: AutonomyGuardPolicy;
+export interface AutonomyGuardEvaluationInput {
+  goal: string;
+  consent: CareConsentState;
+  optimizationTargets?: readonly CareOptimizationTarget[];
+  signals?: readonly CareSignal[];
+  hasDisengagePath?: boolean;
+  preservesOutsideSupport?: boolean;
+  respectsDataBoundary?: boolean;
+  policy?: AutonomyGuardPolicy;
+}
+export interface AutonomyGuardDecision {
+  allowed: boolean;
+  policyId: string;
+  goal: string;
+  blocked: readonly AutonomyGuardBlock[];
+  acceptedOptimizationTargets: readonly CarePositiveOptimizationTarget[];
+}
+export type RepairLoopStatus = 'open' | 'acknowledged' | 'repairing' | 'verified' | 'closed';
+export type RepairLoopAction = 'acknowledge' | 'explain' | 'amend' | 'verify' | 'close';
+export interface RepairLoopStep { at: string; actor: CareActor; action: RepairLoopAction; note: string; evidenceRefs?: readonly string[]; }
+export interface RepairLoop { loopId: string; openedAt: string; status: RepairLoopStatus; harmOrMismatch: string; steps: readonly RepairLoopStep[]; }
+export type GratitudeVisibility = 'private' | 'team' | 'public';
+export interface GratitudeLedgerEntry { entryId: string; recordedAt: string; from: CareActor; to: CareActor; contribution: string; visibility: GratitudeVisibility; evidenceRefs?: readonly string[]; }
+export type RelationalMemoryRetention = 'ephemeral' | 'session' | 'durable';
+export interface RelationalMemoryEntry { memoryId: string; recordedAt: string; subject: CareActor; summary: string; consent: CareConsentState; retention: RelationalMemoryRetention; evidenceRefs?: readonly string[]; }
+export interface CareField {
+  schemaVersion: '1.0.0';
+  fieldId: string;
+  createdAt: string;
+  steward: CareActor;
+  counterpart: CareActor;
+  goal: string;
+  primitives: readonly CarePrimitiveKind[];
+  boundaries: readonly CareBoundary[];
+  consent: CareConsentState;
+  autonomy: AutonomyGuardDecision;
+  repairLoops: readonly RepairLoop[];
+  gratitudeLedger: readonly GratitudeLedgerEntry[];
+  relationalMemory: readonly RelationalMemoryEntry[];
+}
+export interface CreateCareFieldInput {
+  createdAt: string;
+  steward: CareActor;
+  counterpart: CareActor;
+  goal: string;
+  consent: CareConsentState;
+  autonomy?: Omit<AutonomyGuardEvaluationInput, 'goal' | 'consent'>;
+  fieldId?: string;
+  primitives?: readonly CarePrimitiveKind[];
+  boundaries?: readonly CareBoundary[];
+  repairLoops?: readonly RepairLoop[];
+  gratitudeLedger?: readonly GratitudeLedgerEntry[];
+  relationalMemory?: readonly RelationalMemoryEntry[];
+}
+export interface CreateRepairLoopInput { openedAt: string; actor: CareActor; harmOrMismatch: string; note: string; loopId?: string; evidenceRefs?: readonly string[]; }
+export interface RecordGratitudeInput { recordedAt: string; from: CareActor; to: CareActor; contribution: string; visibility?: GratitudeVisibility; entryId?: string; evidenceRefs?: readonly string[]; }
+export interface RememberRelationalContextInput { recordedAt: string; subject: CareActor; summary: string; consent: CareConsentState; retention?: RelationalMemoryRetention; memoryId?: string; evidenceRefs?: readonly string[]; }
+export declare function evaluateAutonomyGuard(input: AutonomyGuardEvaluationInput): AutonomyGuardDecision;
+export declare function createCareField(input: CreateCareFieldInput): CareField;
+export declare function createRepairLoop(input: CreateRepairLoopInput): RepairLoop;
+export declare function recordGratitude(input: RecordGratitudeInput): GratitudeLedgerEntry;
+export declare function rememberRelationalContext(input: RememberRelationalContextInput): RelationalMemoryEntry;
+export declare function validateCareField(field: CareField): { valid: boolean; errors: string[] };
+
+// ============================================================================
+// CONVERSATION DAEMON PRIMITIVES (D.052 Brittney field / user daemon model)
+// ============================================================================
+
+export type DaemonOwnerPolicy = 'private' | 'shared_household' | 'workspace';
+export type MemoryRetentionPolicy = 'session_only' | 'persisted_local' | 'persisted_with_absorb';
+export type DispatchConfidence = 'autonomous' | 'confirm_before' | 'always_ask';
+export interface DaemonAppearanceProfile { characterClass?: string; visualStyle?: string; colorPalette?: string[]; animationSet?: string; scale?: 'tiny' | 'small' | 'medium' | 'large'; }
+export interface DaemonVoiceProfile { enabled: boolean; voiceId?: string; speed?: number; tone?: 'warm' | 'neutral' | 'formal' | 'playful'; }
+export interface DaemonToneProfile { formality?: 'casual' | 'balanced' | 'formal'; verbosity?: 'terse' | 'balanced' | 'detailed'; humor?: 'none' | 'light' | 'moderate'; patience?: 'quick' | 'patient'; }
+export interface DaemonPermissionProfile { readOnly: boolean; proposeMutations: boolean; autonomousMutations: boolean; breakGlassAllowed: boolean; custodyScope: string[]; permissionEnvelope: 'read_only' | 'guarded_execute' | 'break_glass'; }
+export interface DaemonMemoryPolicy { retention: MemoryRetentionPolicy; maxContextWindowTokens?: number; absorbIntegration: boolean; ownerScoped: true; }
+export type DaemonContextSourceKind = 'operator_brief' | 'holoscript_surface_map' | 'absorb_graph' | 'holomesh_lanes' | 'recent_receipts' | 'room_state' | 'holoscript_tool_manifest';
+export interface DaemonDispatchPolicy { defaultConfidence: DispatchConfidence; trustedPatterns: string[]; receiptRequired: boolean; maxAutonomousActionsPerSession: number; }
+export interface DaemonReceiptSink { local: boolean; holoshell: boolean; absorb: boolean; holomesh: boolean; }
+export interface DaemonBrittneyRehydrationChannel { enabled: boolean; channelId: string; deltaCompression: boolean; minimumDeltaSignificance: number; }
+export interface ConversationDaemon { daemonId: string; ownerId: string; ownerPolicy: DaemonOwnerPolicy; displayName: string; appearanceProfile: DaemonAppearanceProfile; voiceProfile: DaemonVoiceProfile; careProfile: string; toneProfile: DaemonToneProfile; permissionProfile: DaemonPermissionProfile; memoryPolicy: DaemonMemoryPolicy; contextSources: DaemonContextSourceKind[]; dispatchPolicy: DaemonDispatchPolicy; receiptSink: DaemonReceiptSink; brittneyRehydrationChannel: DaemonBrittneyRehydrationChannel; createdAt: string; lastActiveAt?: string; }
+export type DaemonUrgencyLevel = 'low' | 'medium' | 'high' | 'immediate';
+export type DaemonConsentBoundary = 'no_action' | 'read_only' | 'propose' | 'execute';
+export interface ExtractedIntent { verb: string; target?: string; parameters: Record<string, unknown>; confidence: number; }
+export interface ExtractedArtifact { kind: 'file' | 'url' | 'entity' | 'code' | 'receipt' | 'task'; ref: string; label?: string; }
+export interface ContextDelta { newIntentSignals: ExtractedIntent[]; updatedPreferences: Record<string, unknown>; newReceiptRefs: string[]; capabilityUpdates: Array<{ capability: string; available: boolean }>; careSignalHistory: string[]; significanceScore: number; }
+export interface ProposedAction { actionId: string; description: string; toolRef: string; parameters: Record<string, unknown>; permissionEnvelope: 'read_only' | 'guarded_execute' | 'break_glass'; reversible: boolean; estimatedImpact: 'none' | 'minor' | 'moderate' | 'significant'; }
+export interface ConversationDaemonTurn { turnId: string; daemonId: string; surfaceId: string; userUtterance: string; selectedShellObject?: string; extractedIntent?: ExtractedIntent; extractedArtifacts: ExtractedArtifact[]; careSignal?: string; urgency: DaemonUrgencyLevel; consentBoundary: DaemonConsentBoundary; contextDelta: ContextDelta; proposedNextAction?: ProposedAction; requiredApproval: boolean; receiptLinks: string[]; timestamp: string; }
+export declare class DaemonFieldSeparationError extends Error { constructor(message: string); }
+export declare function assertDaemonFieldSeparation(daemon: ConversationDaemon): void;
+export declare function makeDefaultConversationDaemon(daemonId: string, ownerId: string, displayName: string, careProfile: string): ConversationDaemon;
+export declare function makeEmptyContextDelta(): ContextDelta;
+export declare function generateROS2LaunchFile(packageName: string, urdfFilename: string, options?: { useSimTime?: boolean; rviz?: boolean; gazebo?: boolean; controllers?: string[]; }): string;
+export declare function generateControllersYaml(robotName: string, jointNames: string[], options?: { controllerType?: string; publishRate?: number; }): string;
+
+
+// Daemon Customization Profile (D.052 Brittney field / user daemon model extended)
+// Matches packages/core/src/daemon/DaemonCustomizationProfile.ts source types
+export interface DaemonRitual { name: string; trigger: string; description: string; enabled: boolean; }
+export interface DaemonFavoriteWorkflow { name: string; workflowId: string; description: string; }
+export interface DaemonStyleProfile { displayName: string; appearance: DaemonAppearanceProfile; voice: DaemonVoiceProfile; tone: DaemonToneProfile; careProfile: string; rituals: DaemonRitual[]; favoriteWorkflows: DaemonFavoriteWorkflow[]; visualTheme: string; personalNotes?: string; }
+export interface DaemonPermissionConfig { readOnly: boolean; proposeMutations: boolean; autonomousMutations: boolean; breakGlassAllowed: boolean; custodyScope: string[]; permissionEnvelope: 'read_only' | 'guarded_execute' | 'break_glass'; }
+export interface DaemonCustomizationProfile { profileId: string; ownerId: string; version: number; createdAt: string; updatedAt: string; style: DaemonStyleProfile; permissions: DaemonPermissionConfig; }
+export type DaemonCareProfile = 'attentive' | 'steady' | 'minimal' | 'intensive';
+export type DaemonVisualTheme = 'classic' | 'compact' | 'expanded' | 'terminal' | 'narrative';
+
+export const DAEMON_VISUAL_THEMES: Record<string, DaemonVisualTheme>;
+export const DAEMON_CARE_PROFILES: Record<string, DaemonCareProfile>;
+
+export class DaemonCustomizationSeparationError extends Error { constructor(message: string); }
+
+export declare function assertCustomizationSeparation(profile: DaemonCustomizationProfile): void;
+export declare function validateCustomizationProfile(profile: DaemonCustomizationProfile): string[];
+export declare function makeDefaultStyleProfile(displayName?: string, careProfile?: string): DaemonStyleProfile;
+export declare function makeDefaultPermissionConfig(): DaemonPermissionConfig;
+export declare function makeDefaultCustomizationProfile(profileId: string, ownerId: string, displayName?: string, careProfile?: string): DaemonCustomizationProfile;
+export declare function customizationProfileToDaemon(profile: DaemonCustomizationProfile): ConversationDaemon;
+export declare function daemonToCustomizationProfile(daemon: ConversationDaemon): DaemonCustomizationProfile;
+export declare function mergeStyleUpdates(profile: DaemonCustomizationProfile, styleUpdates: Partial<DaemonStyleProfile>): DaemonCustomizationProfile;
+export declare function mergePermissionUpdates(base: DaemonPermissionConfig, updates: Partial<DaemonPermissionConfig>): DaemonPermissionConfig;
+export declare function makePresetProfile(preset: 'companion' | 'professional' | 'creative' | 'minimal' | 'guardian', profileId: string, ownerId: string): DaemonCustomizationProfile;
+
+
+// Pipeline parser (barrel/material-io-pipeline re-export)
+export function parsePipeline(source: string): { success: boolean; errors: any[]; ast?: any; [key: string]: any };
+export function isPipelineSource(source: string): boolean;
+
+// Version utilities
+export function getVersionInfo(): { version: string; [key: string]: any };
+export function getVersionString(): string;
+
+// Semantic diff
+export interface SemanticDiffResult { [key: string]: any; }
+export class SemanticDiffEngine { constructor(options?: any); diff(a: any, b: any, ...args: any[]): SemanticDiffResult; [key: string]: any; }
+export function formatDiffResult(result: any): string;
+
+// Pipeline compilation helpers
+export function compilePipelineSourceToNode(source: string, options?: any): any;
+export function parseHoloPartial(source: string, options?: any): any;
+
+// WASM compilation
+export function compileToWASM(ast: any, options?: any): any;
+
+// Compilers re-exported to main barrel for dynamic import callers
+export class FlatSemanticCompiler { constructor(options?: any); compile(ast: any, ...args: any[]): any; [key: string]: any; }
+export class SCMCompiler { constructor(options?: any); compile(ast: any, token?: any): any; [key: string]: any; }
+export class GaussianSplattingCompiler { constructor(options?: { format?: 'gltf' | 'glb'; [key: string]: any }); compile(ast: any, token?: any, ...args: any[]): any; [key: string]: any; }
+
+// Worker proxy for LSP
+export class CompilerWorkerProxy { [key: string]: any; }
+
+// HoloZone for build tools
+export interface HoloZone { name?: string; [key: string]: any; }
+
+// LSP completions data
+export const ErrorRecovery: any;
+export const HOLOSCHEMA_KEYWORDS: string[];
+export const HOLOSCHEMA_GEOMETRIES: string[];
+export const HOLOSCHEMA_PROPERTIES: string[];