@holoscript/core 6.0.4 → 7.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 HoloScript Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -49,7 +49,7 @@ const output = compiler.compile(ast);
 | `HoloScriptPlusParser`  | `.hsplus`  | Extended syntax with TypeScript modules |
 | `HoloCompositionParser` | `.holo`    | Scene-centric composition files         |
 | `HoloScript2DParser`    | `.hs`      | Basic logic and protocols               |
-| `HoloScriptParser`      | `.hs`      | Legacy parser                           |
+| `HoloScriptParser`      | `.hs`      | Standard semantic parser                |
 
 ## Compilers (30+ implementations; verify live targets via health + ExportTarget enum)
 

package/dist/compiler/index.d.ts

@@ -63,6 +63,19 @@ export class IncrementalCompiler extends CompilerBase { compile(ast: any, token:
 export class MultiLayerCompiler extends CompilerBase { compile(ast: any, token: CompilerToken): any; }
 export class COCOExporter { [key: string]: any; }
 export class GLTFPipelineMCPTool { [key: string]: any; }
+export const BUSINESS_QUEST_TOOLS: any[];
+export function registerBusinessQuestTools(server: any): void;
+export function handleBusinessQuestToolCall(request: any): Promise<any>;
+export function buildVRRCompositionFromDraft(draft: any): any;
+export function validateBusinessVRRDraft(
+  draft: unknown,
+  options?: { parseWithVrrCompiler?: boolean }
+): Promise<any>;
+export function draftToHoloPreview(draft: any): string;
+export const businessVRRDraftSchema: any;
+export type BusinessVRRDraft = any;
+export type BusinessQuestValidationIssue = any;
+export type BusinessQuestValidationResult = any;
 export class NodeToyMapping { [key: string]: any; }
 export class RemotionBridge { [key: string]: any; }
 export class ReproducibilityMode { [key: string]: any; }
@@ -83,9 +96,78 @@ export interface SafetyReport { [key: string]: any; }
 export type SafetyVerdict = 'safe' | 'warnings' | 'unsafe' | 'unchecked';
 export interface LinearCheckerConfig { [key: string]: any; }
 export interface InferredEffects { [key: string]: any; }
+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; }
 export type CompilePlatformTarget = string;
 
 export class USDZPipeline { [key: string]: any; }
 export interface USDZPipelineOptions { [key: string]: any; }
 
 export class CompilerBridge { [key: string]: any; }
+
+// Social Causal Model (SCM) — Cycle 9/10/12
+export interface AffectiveState {
+  valence: number;
+  arousal: number;
+  dominantEmotion: 'calm' | 'excited' | 'frustrated' | 'engaged' | 'bored' | 'anxious';
+}
+
+export interface SCMCompilerOptions {
+  modelName?: string;
+  affectiveContext?: AffectiveState;
+  privacyMask?: boolean;
+}
+
+export interface SCMNode {
+  id: string;
+  type: string;
+  properties: Record<string, any>;
+  do_capable: boolean;
+}
+
+export interface SCMEdge {
+  source: string;
+  target: string;
+  relation: string;
+  weight: number;
+}
+
+export interface SCMDAG {
+  metadata: {
+    model_name: string;
+    generated_at: string;
+    affective_context?: AffectiveState;
+  };
+  nodes: SCMNode[];
+  edges: SCMEdge[];
+}
+
+export class SCMCompiler extends CompilerBase {
+  constructor(options?: SCMCompilerOptions);
+  compile(composition: any, agentToken: string, outputPath?: string): string;
+}
+
+export interface SocialMergeOptions {
+  consensusThreshold?: number;
+  modelName?: string;
+}
+
+export interface SocialMergeReport {
+  agents: number;
+  threshold: number;
+  nodes: { kept: number; dropped: number };
+  edges: { kept: number; dropped: number; smoothed: number };
+}
+
+export interface SocialMergeResult {
+  dag: SCMDAG;
+  report: SocialMergeReport;
+}
+
+export function mergeSocialCausalModels(
+  agentDags: SCMDAG[],
+  options?: SocialMergeOptions,
+): SocialMergeResult;

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 // @holoscript/core/constants — trait name constants
-export { VR_TRAITS } from './traits/index.js';
-export type { VRTraitName } from './traits/index.js';
+// VR_TRAITS lives in the main bundle (chunk), not in dist/traits/index.js
+export { VR_TRAITS } from './index.js';
+export type { VRTraitName } from './index.js';

package/dist/coordinators/index.d.ts

@@ -0,0 +1,189 @@
+/** @holoscript/core/coordinators — Pattern E consumer-bus infrastructure (4 buses) */
+
+// --- Shared duck-typed event source ---
+export interface CoordinatorEventSource {
+  on(event: string, handler: (payload: unknown) => void): void;
+}
+
+// --- AssetLoadCoordinator ---
+export type AssetLoadStatus = 'idle' | 'loading' | 'loaded' | 'error';
+export interface AssetLoadState {
+  url: string;
+  format: 'gltf' | 'usd' | 'fbx' | 'unknown';
+  status: AssetLoadStatus;
+  progress: number;
+  error?: string;
+  updatedAt: number;
+}
+export interface AssetLoadStats {
+  total: number;
+  loading: number;
+  loaded: number;
+  failed: number;
+  averageProgress: number;
+}
+export type AssetLoadListener = (state: AssetLoadState) => void;
+export declare class AssetLoadCoordinator {
+  constructor(source: CoordinatorEventSource);
+  subscribe(listener: AssetLoadListener): () => void;
+  getAllStates(): AssetLoadState[];
+  getStats(): AssetLoadStats;
+  reset(): void;
+}
+
+// --- SecurityEventBus ---
+export interface SessionState {
+  sessionId: string;
+  status: 'authenticated' | 'expired' | 'revoked';
+  idp?: string;
+  userId?: string;
+  updatedAt: number;
+}
+export interface AuthorizationState {
+  agentId: string;
+  tenantId?: string;
+  roles: Set<string>;
+  capabilities: Set<string>;
+  updatedAt: number;
+}
+export interface QuotaState {
+  resource: string;
+  subject: string;
+  consumed: number;
+  limit: number;
+  status: 'ok' | 'threshold_reached' | 'grace' | 'exceeded';
+  updatedAt: number;
+}
+export interface TenantState {
+  tenantId: string;
+  status: 'provisioned' | 'active' | 'suspended' | 'decommissioned';
+  tier?: string;
+  updatedAt: number;
+}
+export interface AuditLogEntry {
+  event: string;
+  action?: string;
+  actor?: string;
+  tenantId?: string;
+  outcome?: 'success' | 'denied' | 'error';
+  observedAt: number;
+}
+export interface SecurityStats {
+  sessions: { authenticated: number; expired: number; revoked: number };
+  agents: { tracked: number };
+  tenants: { active: number; suspended: number; decommissioned: number };
+  quotas: { tracked: number; exceeded: number; grace: number };
+  auditLog: { entries: number; capacity: number };
+}
+export interface SecurityEventEnvelope {
+  domain: 'auth' | 'authz' | 'quota' | 'tenant' | 'audit' | 'forget' | 'unknown';
+  event: string;
+  payload: unknown;
+  observedAt: number;
+}
+export type SecurityEventListener = (envelope: SecurityEventEnvelope) => void;
+export declare class SecurityEventBus {
+  constructor(source: CoordinatorEventSource);
+  subscribe(listener: SecurityEventListener): () => void;
+  getAllSessions(): SessionState[];
+  getAuditLog(): AuditLogEntry[];
+  getStats(): SecurityStats;
+  reset(): void;
+}
+
+// --- GenerativeJobMonitor ---
+export type GenerativeJobKind = 'inpainting' | 'texture_gen' | 'controlnet' | 'diffusion_rt';
+export type GenerativeJobStatus =
+  | 'queued'
+  | 'running'
+  | 'completed'
+  | 'cancelled'
+  | 'errored';
+export interface GenerativeJobState {
+  jobId: string;
+  kind: GenerativeJobKind;
+  status: GenerativeJobStatus;
+  startedAt: number;
+  updatedAt: number;
+  durationMs?: number;
+  error?: string;
+}
+export interface GenerativeJobKindStats {
+  queued: number;
+  running: number;
+  completed: number;
+  cancelled: number;
+  errored: number;
+  meanLatencyMs: number;
+}
+export interface GenerativeJobStats {
+  total: number;
+  byKind: Record<GenerativeJobKind, GenerativeJobKindStats>;
+  anyReady: boolean;
+}
+export type GenerativeJobListener = (state: GenerativeJobState) => void;
+export declare class GenerativeJobMonitor {
+  constructor(source: CoordinatorEventSource);
+  subscribe(listener: GenerativeJobListener): () => void;
+  getAllJobs(): GenerativeJobState[];
+  getStats(): GenerativeJobStats;
+  reset(): void;
+}
+
+// --- SessionPresenceCoordinator ---
+export type PresenceDomain = 'shareplay' | 'voice' | 'messaging' | 'heartbeat' | 'unknown';
+export type SessionStatus = 'idle' | 'started' | 'joined' | 'ended';
+export interface SharePlaySessionState {
+  sessionId: string;
+  status: SessionStatus;
+  participants: Set<string>;
+  activityTitle?: string;
+  updatedAt: number;
+}
+export interface SpatialVoiceState {
+  nodeId: string;
+  peers: Set<string>;
+  muted: boolean;
+  lastVoiceActivityAt: number;
+  updatedAt: number;
+}
+export type MessagingConnectionStatus = 'disconnected' | 'connected' | 'errored';
+export interface MessagingConnectionState {
+  platform: string;
+  status: MessagingConnectionStatus;
+  messagesReceived: number;
+  messagesSent: number;
+  error?: string;
+  updatedAt: number;
+}
+export interface HeartbeatState {
+  nodeId: string;
+  status: 'initialized' | 'alive' | 'failover' | 'errored';
+  ticks: number;
+  lastTickAt: number;
+  error?: string;
+  updatedAt: number;
+}
+export interface SessionPresenceStats {
+  sessions: { active: number; ended: number; participants: number };
+  voice: { nodes: number; peers: number; muted: number };
+  messaging: { connections: number; connected: number; errored: number };
+  heartbeat: { tracked: number; alive: number; failover: number; errored: number };
+}
+export interface SessionPresenceEnvelope {
+  domain: PresenceDomain;
+  event: string;
+  payload: unknown;
+  observedAt: number;
+}
+export type SessionPresenceListener = (envelope: SessionPresenceEnvelope) => void;
+export declare class SessionPresenceCoordinator {
+  constructor(source: CoordinatorEventSource);
+  subscribe(listener: SessionPresenceListener): () => void;
+  getAllSessions(): SharePlaySessionState[];
+  getAllVoiceNodes(): SpatialVoiceState[];
+  getAllMessagingConnections(): MessagingConnectionState[];
+  getAllHeartbeats(): HeartbeatState[];
+  getStats(): SessionPresenceStats;
+  reset(): void;
+}