@holoscript/core 7.0.0 → 8.0.0

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,36 @@ 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;
@@ -138,6 +303,7 @@ export interface HoloObjectTrait extends ASTNode {
   name: string;
   config?: any;
   args?: any[];
+  platformConstraint?: PlatformConstraint;
 }
 
 export interface HoloSpatialGroup extends ASTNode {
@@ -695,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 {
@@ -718,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 {
@@ -966,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;
@@ -1013,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;
@@ -1541,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
@@ -1675,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
@@ -2113,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
@@ -2723,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)
 // ============================================================================
@@ -2925,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;
@@ -2946,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>;
@@ -3399,6 +3698,201 @@ export class WebRTCTransport {
   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 {
@@ -3409,3 +3903,464 @@ export interface HostCapabilities {
   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[];