openlearn-next 0.7.12 → 0.7.13

package/dist/server.cjs

@@ -21290,7 +21290,7 @@ var import_node_fs11 = __toESM(require("node:fs"), 1);
 var import_node_path13 = __toESM(require("node:path"), 1);
 var import_node_url5 = require("node:url");
 var import_meta7 = {};
-var FALLBACK_VERSION = "0.7.12";
+var FALLBACK_VERSION = "0.7.13";
 function readPlatformVersion() {
   const bases = [];
   if (typeof __dirname !== "undefined") bases.push(__dirname);
@@ -29983,924 +29983,6 @@ var ServiceRegistryKernel = class {
   }
 };
 
-// packages/core/bootstrap/composition/composition-validator.ts
-var CompositionValidator = class {
-  static validate(options, pipeline, modules) {
-    const errors = [];
-    const warnings = [];
-    if (options.config && options.config.port !== void 0) {
-      if (options.config.port <= 0 || options.config.port > 65535) {
-        errors.push({
-          code: "INVALID_PORT",
-          message: `Port must be a valid number between 1 and 65535. Received: ${options.config.port}`,
-          target: "config.port"
-        });
-      }
-    }
-    if (!pipeline || pipeline.stages.length === 0) {
-      errors.push({
-        code: "EMPTY_PIPELINE",
-        message: "Bootstrap pipeline is missing or contains zero stages.",
-        target: "pipeline"
-      });
-    }
-    const moduleIds = /* @__PURE__ */ new Set();
-    for (const mod of modules) {
-      if (!mod.id) {
-        errors.push({
-          code: "INVALID_MODULE",
-          message: `Module '${mod.name}' has no unique ID.`,
-          target: "module.id"
-        });
-      } else if (moduleIds.has(mod.id)) {
-        errors.push({
-          code: "DUPLICATE_MODULE",
-          message: `Duplicate composition module detected: '${mod.id}'.`,
-          target: "module.id"
-        });
-      } else {
-        moduleIds.add(mod.id);
-      }
-    }
-    return {
-      isValid: errors.length === 0,
-      errors: Object.freeze(errors),
-      warnings: Object.freeze(warnings)
-    };
-  }
-};
-
-// packages/core/bootstrap/builder/builder-validation-engine.ts
-var BuilderValidationEngine = class {
-  static validate(config, environment, stages) {
-    const errors = [];
-    const warnings = [];
-    if (!["development", "production", "test"].includes(environment)) {
-      errors.push({
-        code: "INVALID_ENVIRONMENT",
-        message: `Environment must be one of 'development', 'production', 'test'. Received: '${environment}'`,
-        field: "environment"
-      });
-    }
-    if (!config.port || config.port <= 0 || config.port > 65535) {
-      errors.push({
-        code: "INVALID_PORT",
-        message: `Port must be a valid number between 1 and 65535. Received: ${config.port}`,
-        field: "port"
-      });
-    }
-    if (!stages || stages.length === 0) {
-      errors.push({
-        code: "MISSING_STAGES",
-        message: "Bootstrap pipeline contains no registered stages.",
-        field: "stages"
-      });
-    } else {
-      const stageIds = /* @__PURE__ */ new Set();
-      for (const stage of stages) {
-        if (!stage.id) {
-          errors.push({
-            code: "INVALID_STAGE",
-            message: `Stage '${stage.name}' has no unique ID.`
-          });
-        } else if (stageIds.has(stage.id)) {
-          errors.push({
-            code: "DUPLICATE_STAGE",
-            message: `Duplicate stage registration detected for stage ID '${stage.id}'.`,
-            field: "stage.id"
-          });
-        } else {
-          stageIds.add(stage.id);
-        }
-      }
-    }
-    return {
-      isValid: errors.length === 0,
-      errors: Object.freeze(errors),
-      warnings: Object.freeze(warnings)
-    };
-  }
-};
-
-// packages/core/bootstrap/types/index.ts
-var PlatformBootstrapError = class extends Error {
-  constructor(message, stage, cause) {
-    super(`[PlatformBootstrapError${stage ? `:${stage}` : ""}] ${message}`);
-    this.stage = stage;
-    this.cause = cause;
-    this.name = "PlatformBootstrapError";
-  }
-};
-var ConfigurationError = class extends PlatformBootstrapError {
-  constructor(message, cause) {
-    super(message, "Configuring" /* Configuring */, cause);
-    this.name = "ConfigurationError";
-  }
-};
-var StartupTimeoutError = class extends PlatformBootstrapError {
-  constructor(message, stage, cause) {
-    super(message, stage, cause);
-    this.name = "StartupTimeoutError";
-  }
-};
-var PLATFORM_VERSION2 = PLATFORM_VERSION;
-var BOOTSTRAP_STAGE_NAMES = Object.freeze([
-  "Created" /* Created */,
-  "Configuring" /* Configuring */,
-  "Registering" /* Registering */,
-  "Initializing" /* Initializing */,
-  "Activating" /* Activating */,
-  "Ready" /* Ready */,
-  "ShuttingDown" /* ShuttingDown */,
-  "Disposed" /* Disposed */
-]);
-var DEFAULT_BOOTSTRAP_CONFIG = Object.freeze({
-  environment: "development",
-  mode: "standalone",
-  port: 9e3,
-  debug: false,
-  pluginsDir: "./plugins",
-  dbPath: "./packages/core/db/educational_os.db"
-});
-
-// packages/core/bootstrap/pipeline/pipeline-executor.ts
-var PipelineExecutor = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Set();
-  }
-  addListener(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  emit(event) {
-    for (const listener of Array.from(this.listeners)) {
-      try {
-        listener(event);
-      } catch (err) {
-        console.error("[PipelineExecutor] Listener error:", err);
-      }
-    }
-  }
-  async execute(stages, context) {
-    const startTime = Date.now();
-    const results = [];
-    const executedStages = [];
-    this.emit({ type: "PipelineStarted", timestamp: startTime });
-    console.log("[Platform] Starting Bootstrap Pipeline execution...");
-    for (const stage of stages) {
-      if (context.isCancelled) {
-        console.warn(`[Platform] Pipeline cancelled before stage ${stage.name}`);
-        const totalDurationMs2 = Date.now() - startTime;
-        return {
-          totalDurationMs: totalDurationMs2,
-          status: "Aborted",
-          stageResults: Object.freeze(results)
-        };
-      }
-      console.log(`[Platform] Entering ${stage.name}`);
-      this.emit({
-        type: "StageStarted",
-        timestamp: Date.now(),
-        stageId: stage.id,
-        stageName: String(stage.name)
-      });
-      const stageStart = Date.now();
-      try {
-        if (stage.timeoutMs && stage.timeoutMs > 0) {
-          await this.executeWithTimeout(stage, context, stage.timeoutMs);
-        } else {
-          await stage.execute(context);
-        }
-        const durationMs = Date.now() - stageStart;
-        console.log(`[Platform] Completed ${stage.name} (${durationMs} ms)`);
-        results.push({
-          stageId: stage.id,
-          stageName: String(stage.name),
-          durationMs,
-          status: "Success"
-        });
-        executedStages.push(stage);
-        this.emit({
-          type: "StageCompleted",
-          timestamp: Date.now(),
-          stageId: stage.id,
-          stageName: String(stage.name),
-          durationMs
-        });
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        const durationMs = Date.now() - stageStart;
-        console.error(`[Platform] Failed ${stage.name} (${durationMs} ms): ${error.message}`);
-        results.push({
-          stageId: stage.id,
-          stageName: String(stage.name),
-          durationMs,
-          status: "Failed",
-          error
-        });
-        this.emit({
-          type: "StageFailed",
-          timestamp: Date.now(),
-          stageId: stage.id,
-          stageName: String(stage.name),
-          durationMs,
-          error
-        });
-        await this.rollbackExecutedStages(executedStages, context);
-        const totalDurationMs2 = Date.now() - startTime;
-        const pipelineResult = {
-          totalDurationMs: totalDurationMs2,
-          status: "Failed",
-          stageResults: Object.freeze(results),
-          failedStage: stage.id,
-          error
-        };
-        this.emit({
-          type: "PipelineCompleted",
-          timestamp: Date.now(),
-          durationMs: totalDurationMs2,
-          error
-        });
-        return pipelineResult;
-      }
-    }
-    const totalDurationMs = Date.now() - startTime;
-    console.log(`[Platform] Ready. Total startup duration: ${totalDurationMs} ms.`);
-    const finalResult = {
-      totalDurationMs,
-      status: "Success",
-      stageResults: Object.freeze(results)
-    };
-    this.emit({
-      type: "PipelineCompleted",
-      timestamp: Date.now(),
-      durationMs: totalDurationMs
-    });
-    return finalResult;
-  }
-  async executeWithTimeout(stage, context, timeoutMs) {
-    let timer;
-    const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        reject(new StartupTimeoutError(`Stage execution timed out after ${timeoutMs} ms`));
-      }, timeoutMs);
-    });
-    try {
-      await Promise.race([stage.execute(context), timeoutPromise]);
-    } finally {
-      if (timer) {
-        clearTimeout(timer);
-      }
-    }
-  }
-  async rollbackExecutedStages(executedStages, context) {
-    console.log("[Platform] Triggering stage rollbacks...");
-    for (let i = executedStages.length - 1; i >= 0; i--) {
-      const stage = executedStages[i];
-      if (stage.rollback) {
-        try {
-          console.log(`[Platform] Rolling back ${stage.name}`);
-          await stage.rollback(context);
-        } catch (rbErr) {
-          console.error(`[Platform] Error during rollback of ${stage.name}:`, rbErr);
-        }
-      }
-    }
-  }
-};
-
-// packages/core/bootstrap/pipeline/stages/standard-stages.ts
-var StartupStageImpl = class {
-  constructor() {
-    this.id = "stage_startup";
-    this.name = "Created" /* Created */;
-    this.description = "Environment & configuration validation";
-  }
-  async execute(context) {
-    context.setStage("Configuring" /* Configuring */);
-  }
-};
-var RegistrationStageImpl = class {
-  constructor() {
-    this.id = "stage_registration";
-    this.name = "Registering" /* Registering */;
-    this.description = "Core Service Contracts & DI Tokens registration";
-  }
-  async execute(context) {
-    context.setStage("Registering" /* Registering */);
-  }
-};
-var InitializationStageImpl = class {
-  constructor() {
-    this.id = "stage_initialization";
-    this.name = "Initializing" /* Initializing */;
-    this.description = "Subsystem Kernels initialization";
-  }
-  async execute(context) {
-    context.setStage("Initializing" /* Initializing */);
-  }
-};
-var ActivationStageImpl = class {
-  constructor() {
-    this.id = "stage_activation";
-    this.name = "Activating" /* Activating */;
-    this.description = "Plugin Host discovery & ESM plugins activation";
-  }
-  async execute(context) {
-    context.setStage("Activating" /* Activating */);
-  }
-};
-var ReadyStageImpl = class {
-  constructor() {
-    this.id = "stage_ready";
-    this.name = "Ready" /* Ready */;
-    this.description = "HTTP & Socket.IO server readiness";
-  }
-  async execute(context) {
-    context.setStage("Ready" /* Ready */);
-  }
-};
-
-// packages/core/bootstrap/pipeline/bootstrap-pipeline.ts
-var BootstrapPipeline = class {
-  constructor(stages) {
-    this._stages = [];
-    this.executor = new PipelineExecutor();
-    if (stages && stages.length > 0) {
-      this._stages = [...stages];
-    } else {
-      this._stages = [
-        new StartupStageImpl(),
-        new RegistrationStageImpl(),
-        new InitializationStageImpl(),
-        new ActivationStageImpl(),
-        new ReadyStageImpl()
-      ];
-    }
-  }
-  get stages() {
-    return Object.freeze(this._stages);
-  }
-  addStage(stage) {
-    this._stages.push(stage);
-    return this;
-  }
-  addListener(listener) {
-    return this.executor.addListener(listener);
-  }
-  async run(context) {
-    const result = await this.execute(context);
-    if (result.status === "Failed") {
-      throw result.error || new Error(`Bootstrap Pipeline failed at stage: ${result.failedStage}`);
-    }
-  }
-  async execute(context) {
-    return this.executor.execute(this._stages, context);
-  }
-};
-
-// packages/core/bootstrap/builder/platform-builder.ts
-var DefaultPlatformLogger = class {
-  info(message, ...args) {
-    console.log(`[PlatformBuilder:INFO] ${message}`, ...args);
-  }
-  warn(message, ...args) {
-    console.warn(`[PlatformBuilder:WARN] ${message}`, ...args);
-  }
-  error(message, ...args) {
-    console.error(`[PlatformBuilder:ERROR] ${message}`, ...args);
-  }
-  debug(message, ...args) {
-    console.debug(`[PlatformBuilder:DEBUG] ${message}`, ...args);
-  }
-};
-var PlatformBuilder = class _PlatformBuilder {
-  constructor(options) {
-    this._state = "Created";
-    this._config = { ...DEFAULT_BOOTSTRAP_CONFIG };
-    this._logger = new DefaultPlatformLogger();
-    this._environment = "development";
-    this._metadata = /* @__PURE__ */ new Map();
-    this._services = /* @__PURE__ */ new Map();
-    this._capabilities = /* @__PURE__ */ new Map();
-    this._extensions = /* @__PURE__ */ new Map();
-    this._pipeline = new BootstrapPipeline();
-    this._state = "Created";
-    this._logger.info("Builder Started");
-    if (options) {
-      if (options.config) this.withConfiguration(options.config);
-      if (options.logger) this.withLogger(options.logger);
-      if (options.environment) this.withEnvironment(options.environment);
-      if (options.metadata) {
-        for (const [k, v] of Object.entries(options.metadata)) {
-          this.withMetadata(k, v);
-        }
-      }
-    }
-  }
-  static create(options) {
-    return new _PlatformBuilder(options);
-  }
-  get state() {
-    return this._state;
-  }
-  transitionTo(newState) {
-    if (this._state === "Disposed") {
-      throw new Error("PlatformBuilder has been disposed and cannot accept further transitions.");
-    }
-    if (this._state === "Built" && newState !== "Disposed") {
-      throw new Error(`Invalid state transition from Built to ${newState}. Builder is already built.`);
-    }
-    this._state = newState;
-  }
-  withConfiguration(config) {
-    this.transitionTo("Configuring");
-    this._config = { ...this._config, ...config };
-    if (config.environment) {
-      this._environment = config.environment;
-    }
-    this._logger.info("Configuration Loaded");
-    return this;
-  }
-  withLogger(logger2) {
-    this.transitionTo("Configuring");
-    this._logger = logger2;
-    return this;
-  }
-  withEnvironment(env) {
-    this.transitionTo("Configuring");
-    this._environment = env;
-    this._config = { ...this._config, environment: env };
-    return this;
-  }
-  withMetadata(key, value) {
-    this.transitionTo("Configuring");
-    this._metadata.set(key, value);
-    return this;
-  }
-  addBootstrapStage(stage) {
-    this.transitionTo("Configuring");
-    this._pipeline.addStage(stage);
-    return this;
-  }
-  addService(serviceId, instance) {
-    this.transitionTo("Configuring");
-    this._services.set(serviceId, instance);
-    return this;
-  }
-  addCapability(capabilityId, descriptor) {
-    this.transitionTo("Configuring");
-    this._capabilities.set(capabilityId, descriptor);
-    return this;
-  }
-  addExtension(extensionId, extensionSpec) {
-    this.transitionTo("Configuring");
-    this._extensions.set(extensionId, extensionSpec);
-    return this;
-  }
-  buildResult() {
-    const buildStart = Date.now();
-    this.transitionTo("Validating");
-    this._logger.info("Validation Started");
-    const validation = BuilderValidationEngine.validate(this._config, this._environment, this._pipeline.stages);
-    this._logger.info("Validation Completed");
-    if (!validation.isValid) {
-      this._logger.error(`Validation Failed with ${validation.errors.length} errors.`);
-      throw new ConfigurationError(
-        `PlatformBuilder validation failed: ${validation.errors.map((e) => e.message).join("; ")}`
-      );
-    }
-    this.transitionTo("Building");
-    this._logger.info("Build Started");
-    const platformContext = {
-      platformId: `plt_${globalThis.crypto.randomUUID()}`,
-      version: PLATFORM_VERSION2,
-      namespace: "openlearn.core",
-      mode: this._config.mode,
-      environment: {
-        type: this._environment,
-        isDevelopment: this._environment === "development",
-        isProduction: this._environment === "production",
-        isTest: this._environment === "test",
-        isPluginSandbox: false
-      },
-      config: this._config,
-      featureFlags: {
-        isEnabled: () => true,
-        getFlag: (_, def) => def,
-        getAllFlags: () => ({})
-      },
-      runtimeMetadata: {
-        os: process.platform,
-        nodeVersion: process.version,
-        arch: process.arch,
-        processId: process.pid,
-        memoryUsage: process.memoryUsage(),
-        buildVersion: PLATFORM_VERSION2
-      },
-      bootstrapState: "Bootstrapping",
-      logger: this._logger,
-      diagnostics: {
-        getMetrics: () => ({ uptime: 0 }),
-        getSystemStatus: () => ({ isHealthy: true, activeServicesCount: this._services.size, uptimeSeconds: 0 })
-      },
-      serviceLocator: {
-        hasService: (id) => this._services.has(id),
-        getService: (id) => this._services.get(id)
-      },
-      capabilityCatalog: {
-        hasCapability: (id) => this._capabilities.has(id),
-        getCapability: (id) => this._capabilities.get(id)
-      },
-      extensionCatalog: {
-        hasExtension: (id) => this._extensions.has(id),
-        getExtension: (id) => this._extensions.get(id)
-      },
-      eventDispatcher: {
-        dispatch: async () => {
-        }
-      },
-      shutdownToken: {
-        isRequested: false,
-        onShutdown: () => {
-        }
-      }
-    };
-    const buildDurationMs = Date.now() - buildStart;
-    this.transitionTo("Built");
-    this._logger.info(`Build Completed in ${buildDurationMs} ms`);
-    const result = {
-      platformContext,
-      pipeline: this._pipeline,
-      buildDurationMs,
-      validation,
-      metadata: Object.fromEntries(this._metadata.entries()),
-      builderVersion: PLATFORM_VERSION2
-    };
-    return result;
-  }
-  async build() {
-    const res = this.buildResult();
-    return {
-      currentStage: "Created" /* Created */,
-      context: res.platformContext,
-      pipeline: res.pipeline,
-      start: async () => {
-      },
-      shutdown: async () => {
-      },
-      dispose: async () => {
-      }
-    };
-  }
-  async start() {
-    const kernel = await this.build();
-    await kernel.start();
-    return kernel;
-  }
-  async shutdown() {
-    this.transitionTo("Disposed");
-  }
-  dispose() {
-    this._state = "Disposed";
-    this._services.clear();
-    this._capabilities.clear();
-    this._extensions.clear();
-    this._metadata.clear();
-  }
-};
-
-// packages/core/bootstrap/composition/platform-composition-root.ts
-var PlatformCompositionRoot = class _PlatformCompositionRoot {
-  constructor() {
-    this._state = "Created";
-    this._modules = [];
-    this._state = "Created";
-  }
-  static create() {
-    return new _PlatformCompositionRoot();
-  }
-  get state() {
-    return this._state;
-  }
-  registerModule(module2) {
-    if (this._state === "Disposed" || this._state === "Composed") {
-      throw new Error(`Cannot register composition module in state: ${this._state}`);
-    }
-    this._modules.push(module2);
-    return this;
-  }
-  compose(options) {
-    const startTime = Date.now();
-    this._state = "Validating";
-    const opts = options || {};
-    const builder = PlatformBuilder.create();
-    if (opts.config) builder.withConfiguration(opts.config);
-    if (opts.logger) builder.withLogger(opts.logger);
-    if (opts.environment) builder.withEnvironment(opts.environment);
-    const builderResult = builder.buildResult();
-    const validation = CompositionValidator.validate(opts, builderResult.pipeline, this._modules);
-    if (!validation.isValid) {
-      throw new ConfigurationError(
-        `CompositionRoot validation failed: ${validation.errors.map((e) => e.message).join("; ")}`
-      );
-    }
-    this._state = "Composing";
-    for (const mod of this._modules) {
-      mod.compose(opts);
-    }
-    const durationMs = Date.now() - startTime;
-    this._state = "Composed";
-    return {
-      context: builderResult.platformContext,
-      pipeline: builderResult.pipeline,
-      durationMs,
-      validation
-    };
-  }
-  dispose() {
-    this._state = "Disposed";
-    this._modules = [];
-  }
-};
-
-// packages/core/bootstrap/permission/permission-registry.ts
-var PermissionRegistry = class {
-  constructor() {
-    this.descriptors = /* @__PURE__ */ new Map();
-  }
-  register(descriptor) {
-    if (!descriptor || !descriptor.id) {
-      throw new Error("PermissionRegistry Error: PermissionDescriptor must have a valid ID.");
-    }
-    if (this.descriptors.has(descriptor.id)) {
-      throw new Error(`PermissionRegistry Collision: Permission '${descriptor.id}' is already registered.`);
-    }
-    this.descriptors.set(descriptor.id, Object.freeze({ ...descriptor }));
-  }
-  unregister(permissionId) {
-    return this.descriptors.delete(permissionId);
-  }
-  get(permissionId) {
-    return this.descriptors.get(permissionId);
-  }
-  exists(permissionId) {
-    return this.descriptors.has(permissionId);
-  }
-  list() {
-    return Object.freeze(Array.from(this.descriptors.values()));
-  }
-  clear() {
-    this.descriptors.clear();
-  }
-};
-
-// packages/core/bootstrap/permission/permission-evaluator.ts
-var PermissionEvaluator = class {
-  static async evaluate(subject, permission, explicitGrants, descriptor, providers) {
-    const evaluatedAt = Date.now();
-    const grantKey = `${subject}::${permission}`;
-    if (explicitGrants.has(grantKey)) {
-      const policy = explicitGrants.get(grantKey);
-      if (policy === "Allow") {
-        return { allowed: true, policy: "Allow", reason: "Explicitly granted to subject", evaluatedAt };
-      }
-      if (policy === "Deny") {
-        return { allowed: false, policy: "Deny", reason: "Explicitly denied to subject", evaluatedAt };
-      }
-    }
-    if (providers && providers.length > 0) {
-      for (const provider of providers) {
-        const policy = await provider.getPolicy(subject, permission);
-        if (policy === "Allow") {
-          return { allowed: true, policy: "Allow", reason: `Granted by provider '${provider.id}'`, evaluatedAt };
-        }
-        if (policy === "Deny") {
-          return { allowed: false, policy: "Deny", reason: `Denied by provider '${provider.id}'`, evaluatedAt };
-        }
-      }
-    }
-    if (descriptor && descriptor.defaultPolicy) {
-      const defaultPol = descriptor.defaultPolicy;
-      if (defaultPol === "Allow") {
-        return { allowed: true, policy: "Allow", reason: "Allowed by descriptor default policy", evaluatedAt };
-      }
-      if (defaultPol === "Deny") {
-        return { allowed: false, policy: "Deny", reason: "Denied by descriptor default policy", evaluatedAt };
-      }
-    }
-    return {
-      allowed: false,
-      policy: "Default",
-      reason: "No explicit allow policy resolved; default deny",
-      evaluatedAt
-    };
-  }
-};
-
-// packages/core/bootstrap/permission/permission-manager.ts
-var PermissionManager = class {
-  constructor() {
-    this.registry = new PermissionRegistry();
-    this.grants = /* @__PURE__ */ new Map();
-    this.providers = [];
-  }
-  register(descriptor) {
-    this.registry.register(descriptor);
-  }
-  unregister(permissionId) {
-    return this.registry.unregister(permissionId);
-  }
-  grant(subject, permissionId, policy = "Allow") {
-    const key = `${subject}::${permissionId}`;
-    this.grants.set(key, policy);
-  }
-  revoke(subject, permissionId) {
-    const key = `${subject}::${permissionId}`;
-    this.grants.delete(key);
-  }
-  addProvider(provider) {
-    if (!this.providers.some((p) => p.id === provider.id)) {
-      this.providers.push(provider);
-    }
-  }
-  removeProvider(providerId) {
-    this.providers = this.providers.filter((p) => p.id !== providerId);
-  }
-  exists(permissionId) {
-    return this.registry.exists(permissionId);
-  }
-  list() {
-    return this.registry.list();
-  }
-  async check(subject, target, permissionId, metadata) {
-    const timestamp = Date.now();
-    const descriptor = this.registry.get(permissionId);
-    const result = await PermissionEvaluator.evaluate(subject, permissionId, this.grants, descriptor, this.providers);
-    const context = {
-      subject,
-      target,
-      permission: permissionId,
-      metadata,
-      timestamp,
-      result
-    };
-    return context;
-  }
-  async require(subject, target, permissionId, metadata) {
-    const context = await this.check(subject, target, permissionId, metadata);
-    if (!context.result || !context.result.allowed) {
-      const reason = context.result?.reason || "Permission Denied";
-      throw new Error(
-        `Infrastructure Permission Exception: Subject '${subject}' is denied '${permissionId}' on target '${target}'. Reason: ${reason}`
-      );
-    }
-    return context;
-  }
-  clear() {
-    this.registry.clear();
-    this.grants.clear();
-    this.providers = [];
-  }
-};
-
-// packages/core/bootstrap/composition/plugin-composition-module.ts
-var _sharedPlatformRegistry;
-function getPlatformServiceRegistry() {
-  if (!_sharedPlatformRegistry) {
-    _sharedPlatformRegistry = new PlatformServiceRegistry();
-  }
-  return _sharedPlatformRegistry;
-}
-var PluginCompositionModule = class {
-  constructor() {
-    this.id = "mod_plugin_composition";
-    this.name = "PluginCompositionModule";
-  }
-  compose(options) {
-    const serviceRegistry = getPlatformServiceRegistry();
-    const registerOrReplace = (config) => {
-      const { id, instance } = config;
-      if (serviceRegistry.has(id)) {
-        serviceRegistry.replace(id, instance);
-      } else {
-        serviceRegistry.register({ id }, instance);
-      }
-    };
-    const capabilityRegistry = new CapabilityRegistry();
-    const permissionManager = new PermissionManager();
-    const eventBus = new EventBus();
-    const realPluginHost = options?.infrastructureRefs?.get("pluginHost") ?? {
-      name: "PluginHostService",
-      isReady: true,
-      pluginsCount: 0
-    };
-    const realContributionRegistry = options?.infrastructureRefs?.get("contributionRegistry") ?? {
-      name: "ContributionRegistry",
-      slotsCount: 0
-    };
-    const realRuntimeComposition = options?.infrastructureRefs?.get("runtimeComposition") ?? {
-      name: "PluginRuntimeComposition",
-      isStarted: true
-    };
-    const realLifecycleManager = options?.infrastructureRefs?.get("lifecycleManager") ?? {
-      name: "PluginLifecycleManager",
-      version: PLATFORM_VERSION
-    };
-    const realCapabilityGateway = options?.infrastructureRefs?.get("capabilityGateway") ?? {
-      name: "PluginCapabilityGateway",
-      version: PLATFORM_VERSION
-    };
-    const realExtensionRegistry = options?.infrastructureRefs?.get("extensionRegistry") ?? {
-      name: "UnifiedExtensionRegistry",
-      version: PLATFORM_VERSION
-    };
-    const realDistributionManager = options?.infrastructureRefs?.get("distributionManager") ?? {
-      name: "PluginDistributionManager",
-      version: PLATFORM_VERSION
-    };
-    registerOrReplace({
-      id: "srv_plugin_host",
-      lifetime: "Singleton",
-      description: "OpenLearn Plugin Host Service Engine",
-      instance: realPluginHost
-    });
-    registerOrReplace({
-      id: "srv_plugin_contribution_registry",
-      lifetime: "Singleton",
-      description: "Plugin UI & Slot Contribution Registry",
-      instance: realContributionRegistry
-    });
-    registerOrReplace({
-      id: "srv_plugin_runtime_composition",
-      lifetime: "Singleton",
-      description: "OpenLearn Plugin Runtime Composition Facade",
-      instance: realRuntimeComposition
-    });
-    registerOrReplace({
-      id: "srv_plugin_lifecycle_manager",
-      lifetime: "Singleton",
-      description: "OpenLearn Unified Plugin Lifecycle Manager",
-      instance: realLifecycleManager
-    });
-    registerOrReplace({
-      id: "srv_plugin_capability_gateway",
-      lifetime: "Singleton",
-      description: "OpenLearn Unified Plugin Capability Gateway",
-      instance: realCapabilityGateway
-    });
-    registerOrReplace({
-      id: "srv_unified_extension_registry",
-      lifetime: "Singleton",
-      description: "OpenLearn Unified Extension Registry Foundation",
-      instance: realExtensionRegistry
-    });
-    registerOrReplace({
-      id: "srv_plugin_distribution_manager",
-      lifetime: "Singleton",
-      description: "OpenLearn Plugin Distribution Manager Foundation",
-      instance: realDistributionManager
-    });
-    permissionManager.register({
-      id: "perm_plugin_execute",
-      name: "Plugin Execution Permission",
-      category: "Infrastructure",
-      description: "Allows plugin sandbox execution within Platform",
-      defaultPolicy: "Allow"
-    });
-    permissionManager.register({
-      id: "perm_plugin_install",
-      name: "Plugin Installation Permission",
-      category: "Infrastructure",
-      description: "Allows installing new plugin packages into storage",
-      defaultPolicy: "Allow"
-    });
-    eventBus.publish({
-      id: `evt_${globalThis.crypto.randomUUID()}`,
-      type: "PluginHostInitialized",
-      source: "PluginCompositionModule",
-      payload: { timestamp: Date.now(), status: "Ready" },
-      timestamp: Date.now()
-    });
-    eventBus.publish({
-      id: `evt_${globalThis.crypto.randomUUID()}`,
-      type: "PluginLoaded",
-      source: "PluginCompositionModule",
-      payload: { timestamp: Date.now(), pluginsLoaded: 0 },
-      timestamp: Date.now()
-    });
-    eventBus.publish({
-      id: `evt_${globalThis.crypto.randomUUID()}`,
-      type: "PluginActivated",
-      source: "PluginCompositionModule",
-      payload: { timestamp: Date.now(), activePlugins: [] },
-      timestamp: Date.now()
-    });
-  }
-};
-
 // packages/core/kernel/index.ts
 var import_path12 = __toESM(require("path"), 1);
 var Kernel = class {
@@ -30967,20 +30049,6 @@ var Kernel = class {
     this.unifiedExtensionRegistry = new UnifiedExtensionRegistry();
     this.capabilityRegistry = capabilityRegistry;
     this.pluginCapabilityGateway = new PluginCapabilityGateway(capabilityRegistry);
-    const infrastructureRefs = /* @__PURE__ */ new Map([
-      ["pluginHost", this.pluginHost],
-      ["contributionRegistry", this.pluginHost.getContributionRegistry()],
-      ["runtimeComposition", this.pluginRuntimeComposition],
-      ["lifecycleManager", this.pluginLifecycleManager],
-      ["capabilityGateway", this.pluginCapabilityGateway],
-      ["extensionRegistry", this.unifiedExtensionRegistry],
-      ["distributionManager", this.pluginDistributionManager]
-    ]);
-    try {
-      PlatformCompositionRoot.create().registerModule(new PluginCompositionModule()).compose({ infrastructureRefs });
-    } catch (e) {
-      console.warn("[P7-A2] Plugin composition failed (non-fatal):", e.message);
-    }
     this.serviceRegistry.register(IEventBusServiceToken3, this.eventBus);
     this.serviceRegistry.register(ICapabilityServiceToken, this.capabilityGuard);
     this.serviceRegistry.register(IStorageServiceToken, this.storageService);
@@ -34823,7 +33891,7 @@ function sendSafeError(res, err, status = 500, fallbackMessage = "Internal serve
   }
   const isProd = process.env.NODE_ENV === "production";
   const exposedMessage = isProd && effectiveStatus >= 500 ? fallbackMessage : message;
-  const rawCode = err && typeof err === "object" && typeof err.code === "string" ? err.code : void 0;
+  const rawCode = err && typeof err === "object" && typeof err.code === "string" ? err.code : err && typeof err === "object" && err.type === "entity.too.large" ? "PAYLOAD_TOO_LARGE" : void 0;
   const errorCode = effectiveStatus >= 400 && effectiveStatus < 500 && rawCode ? rawCode : void 0;
   return res.status(effectiveStatus).json({ success: false, ...errorCode ? { code: errorCode } : {}, error: exposedMessage });
 }
@@ -36281,15 +35349,28 @@ var LARGE_UPLOAD_ENDPOINTS = [
   "/api/upload",
   "/api/courseware/upload",
   "/api/courseware/inline",
-  "/api/plugins/upload-zip"
+  "/api/plugins/upload-zip",
+  "/api/resources"
 ];
 var LARGE_UPLOAD_LIMIT = "110mb";
+var MEDIUM_UPLOAD_ENDPOINTS = [
+  "/api/auth/avatar",
+  "/api/timetable/ocr",
+  "/api/site-settings",
+  "/api/agent/chat"
+];
+var MEDIUM_UPLOAD_LIMIT = "30mb";
 function mountLargeBodyParsers(app) {
   app.use(
     LARGE_UPLOAD_ENDPOINTS,
     import_express2.default.json({ limit: LARGE_UPLOAD_LIMIT }),
     import_express2.default.urlencoded({ limit: LARGE_UPLOAD_LIMIT, extended: true })
   );
+  app.use(
+    MEDIUM_UPLOAD_ENDPOINTS,
+    import_express2.default.json({ limit: MEDIUM_UPLOAD_LIMIT }),
+    import_express2.default.urlencoded({ limit: MEDIUM_UPLOAD_LIMIT, extended: true })
+  );
   app.use(
     COURSE_PACKAGE_IMPORT_PATH,
     import_express2.default.json({ limit: COURSE_PACKAGE_IMPORT_BODY_LIMIT_BYTES }),
@@ -36326,211 +35407,753 @@ function call(op, args) {
     pending.set(callId, { resolve: resolve, reject: reject });
     post({ type: 'call', callId: callId, op: op, args: args });
   });
-}
-function makeCtx(pluginId, manifest) {
-  return {
-    pluginId: pluginId,
-    manifest: manifest,
-    services: {
-      frontendApi: {
-        get: function (path) { return call('api.get', [path]); },
-        post: function (path, body) { return call('api.post', [path, body]); },
-        del: function (path) { return call('api.del', [path]); }
-      },
-      storageService: {
-        get: function (key) { return call('storage.get', [key]); },
-        set: function (key, value) { return call('storage.set', [key, value]); },
-        delete: function (key) { return call('storage.delete', [key]); }
+}
+function makeCtx(pluginId, manifest) {
+  return {
+    pluginId: pluginId,
+    manifest: manifest,
+    services: {
+      frontendApi: {
+        get: function (path) { return call('api.get', [path]); },
+        post: function (path, body) { return call('api.post', [path, body]); },
+        del: function (path) { return call('api.del', [path]); }
+      },
+      storageService: {
+        get: function (key) { return call('storage.get', [key]); },
+        set: function (key, value) { return call('storage.set', [key, value]); },
+        delete: function (key) { return call('storage.delete', [key]); }
+      }
+    },
+    ui: {
+      registerExtensionPoint: function (slot, config) { return call('ui.register', [slot, config]); },
+      showToast: function (message) { return call('ui.toast', [message]); }
+    },
+    invokeCommand: function (type, payload) { return call('command.invoke', [type, payload]); },
+    context: { get: function () { return call('context.get', []); } }
+  };
+}
+window.addEventListener('message', async function (event) {
+  const data = event.data;
+  if (!data || data.channel !== CHANNEL || event.source !== parent) return;
+  if (data.type === 'reply') {
+    const waiter = pending.get(data.callId);
+    if (!waiter) return;
+    pending.delete(data.callId);
+    if (data.ok) waiter.resolve(data.value);
+    else waiter.reject(new Error(data.error || 'bridge call failed'));
+    return;
+  }
+  if (data.type === 'deactivate') {
+    try {
+      if (activePlugin && typeof activePlugin.deactivate === 'function') {
+        await activePlugin.deactivate();
+      }
+    } catch (_) {}
+    activePlugin = null;
+    pending.clear();
+    post({ type: 'deactivated', id: data.id });
+    return;
+  }
+  if (data.type !== 'load') return;
+  targetOrigin = event.origin && event.origin !== 'null' ? event.origin : '*';
+  try {
+    const blob = new Blob([data.source], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    let mod;
+    try { mod = await import(url); } finally { URL.revokeObjectURL(url); }
+    const plugin = mod.default || mod;
+    if (typeof plugin.activate !== 'function') throw new Error('missing activate function');
+    activePlugin = plugin;
+    await Promise.race([
+      plugin.activate(makeCtx(data.pluginId, data.manifest)),
+      new Promise(function (_, reject) { setTimeout(function () { reject(new Error('Activation timeout (5000ms)')); }, 5000); })
+    ]);
+    post({ type: 'activated', id: data.id });
+  } catch (error) {
+    post({ type: 'activate-error', id: data.id, error: error && error.message ? error.message : String(error) });
+  }
+});
+post({ type: 'ready' });
+</script>
+</body></html>`;
+
+// server/utils/plugin-view-bridge.ts
+var PLUGIN_VIEW_CSP = "sandbox allow-scripts allow-forms allow-downloads; frame-ancestors 'self'; default-src 'self' 'unsafe-inline' data: blob: https:; script-src 'self' 'unsafe-inline' 'unsafe-eval' data: blob: https:; script-src-attr 'unsafe-inline'; style-src 'self' 'unsafe-inline' data: blob: https:; style-src-attr 'unsafe-inline'; connect-src 'self' blob: data: https:;";
+var PLUGIN_VIEW_BRIDGE_JS = `(function () {
+  'use strict';
+  const CHANNEL = 'ol-plugin-view';
+  let targetOrigin = '*';
+  const pending = new Map();
+  const initCallbacks = [];
+  const contextUpdateCallbacks = [];
+  let currentContext = null;
+
+  function post(msg) {
+    if (window.parent && window.parent !== window) {
+      window.parent.postMessage(Object.assign({ channel: CHANNEL }, msg), targetOrigin);
+    }
+  }
+
+  function call(op, args) {
+    const callId = Math.random().toString(16).slice(2) + Date.now().toString(16);
+    return new Promise(function (resolve, reject) {
+      pending.set(callId, { resolve: resolve, reject: reject });
+      post({ type: 'call', callId: callId, op: op, args: args || [] });
+    });
+  }
+
+  window.addEventListener('message', function (event) {
+    const data = event.data;
+    if (!data || data.channel !== CHANNEL) return;
+    if (event.source !== window.parent) return;
+
+    if (data.type === 'init') {
+      currentContext = data.payload || {};
+      targetOrigin = event.origin && event.origin !== 'null' ? event.origin : '*';
+      for (let i = 0; i < initCallbacks.length; i++) {
+        try {
+          initCallbacks[i](currentContext);
+        } catch (e) {
+          console.error('[OpenLearnPluginBridge] init callback error:', e);
+        }
+      }
+      return;
+    }
+
+    if (data.type === 'context-update') {
+      currentContext = Object.assign({}, currentContext, data.payload || {});
+      for (let i = 0; i < contextUpdateCallbacks.length; i++) {
+        try {
+          contextUpdateCallbacks[i](currentContext);
+        } catch (e) {
+          console.error('[OpenLearnPluginBridge] contextUpdate callback error:', e);
+        }
+      }
+      return;
+    }
+
+    if (data.type === 'reply') {
+      const waiter = pending.get(data.callId);
+      if (!waiter) return;
+      pending.delete(data.callId);
+      if (data.ok) {
+        waiter.resolve(data.value);
+      } else {
+        waiter.reject(new Error(data.error || 'bridge call failed'));
+      }
+      return;
+    }
+  });
+
+  const bridge = {
+    CHANNEL: CHANNEL,
+    onInit: function (callback) {
+      if (typeof callback === 'function') {
+        if (currentContext) {
+          try {
+            callback(currentContext);
+          } catch (e) {
+            console.error('[OpenLearnPluginBridge] onInit callback error:', e);
+          }
+        }
+        initCallbacks.push(callback);
+      }
+      return bridge;
+    },
+    onContextUpdate: function (callback) {
+      if (typeof callback === 'function') {
+        contextUpdateCallbacks.push(callback);
       }
+      return bridge;
+    },
+    getContext: function () {
+      return currentContext;
     },
     ui: {
-      registerExtensionPoint: function (slot, config) { return call('ui.register', [slot, config]); },
-      showToast: function (message) { return call('ui.toast', [message]); }
+      toast: function (message, type) {
+        return call('ui.toast', [message, type || 'info']);
+      },
+      showToast: function (message, type) {
+        return call('ui.toast', [message, type || 'info']);
+      },
+      resize: function (height) {
+        post({ type: 'resize', height: Number(height) || 0 });
+      },
+    },
+    invokeCommand: function (type, payload) {
+      return call('command.invoke', [type, payload]);
+    },
+    api: {
+      get: function (path) {
+        return call('api.get', [path]);
+      },
+      post: function (path, body) {
+        return call('api.post', [path, body]);
+      },
+      del: function (path) {
+        return call('api.del', [path]);
+      },
+    },
+    storage: {
+      get: function (key) {
+        return call('storage.get', [key]);
+      },
+      set: function (key, value) {
+        return call('storage.set', [key, value]);
+      },
+      delete: function (key) {
+        return call('storage.delete', [key]);
+      },
     },
-    invokeCommand: function (type, payload) { return call('command.invoke', [type, payload]); },
-    context: { get: function () { return call('context.get', []); } }
   };
-}
-window.addEventListener('message', async function (event) {
-  const data = event.data;
-  if (!data || data.channel !== CHANNEL || event.source !== parent) return;
-  if (data.type === 'reply') {
-    const waiter = pending.get(data.callId);
-    if (!waiter) return;
-    pending.delete(data.callId);
-    if (data.ok) waiter.resolve(data.value);
-    else waiter.reject(new Error(data.error || 'bridge call failed'));
-    return;
+
+  window.OpenLearnPluginBridge = bridge;
+  // \u901A\u77E5\u5BBF\u4E3B\u89C6\u56FE\u6C99\u7BB1 iframe \u5DF2\u5C31\u7EEA
+  post({ type: 'ready' });
+})();
+`;
+
+// packages/core/bootstrap/types/index.ts
+var PlatformBootstrapError = class extends Error {
+  constructor(message, stage, cause) {
+    super(`[PlatformBootstrapError${stage ? `:${stage}` : ""}] ${message}`);
+    this.stage = stage;
+    this.cause = cause;
+    this.name = "PlatformBootstrapError";
+  }
+};
+var ConfigurationError = class extends PlatformBootstrapError {
+  constructor(message, cause) {
+    super(message, "Configuring" /* Configuring */, cause);
+    this.name = "ConfigurationError";
+  }
+};
+var StartupTimeoutError = class extends PlatformBootstrapError {
+  constructor(message, stage, cause) {
+    super(message, stage, cause);
+    this.name = "StartupTimeoutError";
+  }
+};
+var PLATFORM_VERSION2 = PLATFORM_VERSION;
+var BOOTSTRAP_STAGE_NAMES = Object.freeze([
+  "Created" /* Created */,
+  "Configuring" /* Configuring */,
+  "Registering" /* Registering */,
+  "Initializing" /* Initializing */,
+  "Activating" /* Activating */,
+  "Ready" /* Ready */,
+  "ShuttingDown" /* ShuttingDown */,
+  "Disposed" /* Disposed */
+]);
+var DEFAULT_BOOTSTRAP_CONFIG = Object.freeze({
+  environment: "development",
+  mode: "standalone",
+  port: 9e3,
+  debug: false,
+  pluginsDir: "./plugins",
+  dbPath: "./packages/core/db/educational_os.db"
+});
+
+// packages/core/bootstrap/pipeline/pipeline-executor.ts
+var PipelineExecutor = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emit(event) {
+    for (const listener of Array.from(this.listeners)) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("[PipelineExecutor] Listener error:", err);
+      }
+    }
+  }
+  async execute(stages, context) {
+    const startTime = Date.now();
+    const results = [];
+    const executedStages = [];
+    this.emit({ type: "PipelineStarted", timestamp: startTime });
+    console.log("[Platform] Starting Bootstrap Pipeline execution...");
+    for (const stage of stages) {
+      if (context.isCancelled) {
+        console.warn(`[Platform] Pipeline cancelled before stage ${stage.name}`);
+        const totalDurationMs2 = Date.now() - startTime;
+        return {
+          totalDurationMs: totalDurationMs2,
+          status: "Aborted",
+          stageResults: Object.freeze(results)
+        };
+      }
+      console.log(`[Platform] Entering ${stage.name}`);
+      this.emit({
+        type: "StageStarted",
+        timestamp: Date.now(),
+        stageId: stage.id,
+        stageName: String(stage.name)
+      });
+      const stageStart = Date.now();
+      try {
+        if (stage.timeoutMs && stage.timeoutMs > 0) {
+          await this.executeWithTimeout(stage, context, stage.timeoutMs);
+        } else {
+          await stage.execute(context);
+        }
+        const durationMs = Date.now() - stageStart;
+        console.log(`[Platform] Completed ${stage.name} (${durationMs} ms)`);
+        results.push({
+          stageId: stage.id,
+          stageName: String(stage.name),
+          durationMs,
+          status: "Success"
+        });
+        executedStages.push(stage);
+        this.emit({
+          type: "StageCompleted",
+          timestamp: Date.now(),
+          stageId: stage.id,
+          stageName: String(stage.name),
+          durationMs
+        });
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const durationMs = Date.now() - stageStart;
+        console.error(`[Platform] Failed ${stage.name} (${durationMs} ms): ${error.message}`);
+        results.push({
+          stageId: stage.id,
+          stageName: String(stage.name),
+          durationMs,
+          status: "Failed",
+          error
+        });
+        this.emit({
+          type: "StageFailed",
+          timestamp: Date.now(),
+          stageId: stage.id,
+          stageName: String(stage.name),
+          durationMs,
+          error
+        });
+        await this.rollbackExecutedStages(executedStages, context);
+        const totalDurationMs2 = Date.now() - startTime;
+        const pipelineResult = {
+          totalDurationMs: totalDurationMs2,
+          status: "Failed",
+          stageResults: Object.freeze(results),
+          failedStage: stage.id,
+          error
+        };
+        this.emit({
+          type: "PipelineCompleted",
+          timestamp: Date.now(),
+          durationMs: totalDurationMs2,
+          error
+        });
+        return pipelineResult;
+      }
+    }
+    const totalDurationMs = Date.now() - startTime;
+    console.log(`[Platform] Ready. Total startup duration: ${totalDurationMs} ms.`);
+    const finalResult = {
+      totalDurationMs,
+      status: "Success",
+      stageResults: Object.freeze(results)
+    };
+    this.emit({
+      type: "PipelineCompleted",
+      timestamp: Date.now(),
+      durationMs: totalDurationMs
+    });
+    return finalResult;
   }
-  if (data.type === 'deactivate') {
+  async executeWithTimeout(stage, context, timeoutMs) {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new StartupTimeoutError(`Stage execution timed out after ${timeoutMs} ms`));
+      }, timeoutMs);
+    });
     try {
-      if (activePlugin && typeof activePlugin.deactivate === 'function') {
-        await activePlugin.deactivate();
+      await Promise.race([stage.execute(context), timeoutPromise]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
       }
-    } catch (_) {}
-    activePlugin = null;
-    pending.clear();
-    post({ type: 'deactivated', id: data.id });
-    return;
+    }
   }
-  if (data.type !== 'load') return;
-  targetOrigin = event.origin && event.origin !== 'null' ? event.origin : '*';
-  try {
-    const blob = new Blob([data.source], { type: 'text/javascript' });
-    const url = URL.createObjectURL(blob);
-    let mod;
-    try { mod = await import(url); } finally { URL.revokeObjectURL(url); }
-    const plugin = mod.default || mod;
-    if (typeof plugin.activate !== 'function') throw new Error('missing activate function');
-    activePlugin = plugin;
-    await Promise.race([
-      plugin.activate(makeCtx(data.pluginId, data.manifest)),
-      new Promise(function (_, reject) { setTimeout(function () { reject(new Error('Activation timeout (5000ms)')); }, 5000); })
-    ]);
-    post({ type: 'activated', id: data.id });
-  } catch (error) {
-    post({ type: 'activate-error', id: data.id, error: error && error.message ? error.message : String(error) });
+  async rollbackExecutedStages(executedStages, context) {
+    console.log("[Platform] Triggering stage rollbacks...");
+    for (let i = executedStages.length - 1; i >= 0; i--) {
+      const stage = executedStages[i];
+      if (stage.rollback) {
+        try {
+          console.log(`[Platform] Rolling back ${stage.name}`);
+          await stage.rollback(context);
+        } catch (rbErr) {
+          console.error(`[Platform] Error during rollback of ${stage.name}:`, rbErr);
+        }
+      }
+    }
   }
-});
-post({ type: 'ready' });
-</script>
-</body></html>`;
+};
 
-// server/utils/plugin-view-bridge.ts
-var PLUGIN_VIEW_CSP = "sandbox allow-scripts allow-forms allow-downloads; frame-ancestors 'self'; default-src 'self' 'unsafe-inline' data: blob: https:; script-src 'self' 'unsafe-inline' 'unsafe-eval' data: blob: https:; script-src-attr 'unsafe-inline'; style-src 'self' 'unsafe-inline' data: blob: https:; style-src-attr 'unsafe-inline'; connect-src 'self' blob: data: https:;";
-var PLUGIN_VIEW_BRIDGE_JS = `(function () {
-  'use strict';
-  const CHANNEL = 'ol-plugin-view';
-  let targetOrigin = '*';
-  const pending = new Map();
-  const initCallbacks = [];
-  const contextUpdateCallbacks = [];
-  let currentContext = null;
+// packages/core/bootstrap/pipeline/stages/standard-stages.ts
+var StartupStageImpl = class {
+  constructor() {
+    this.id = "stage_startup";
+    this.name = "Created" /* Created */;
+    this.description = "Environment & configuration validation";
+  }
+  async execute(context) {
+    context.setStage("Configuring" /* Configuring */);
+  }
+};
+var RegistrationStageImpl = class {
+  constructor() {
+    this.id = "stage_registration";
+    this.name = "Registering" /* Registering */;
+    this.description = "Core Service Contracts & DI Tokens registration";
+  }
+  async execute(context) {
+    context.setStage("Registering" /* Registering */);
+  }
+};
+var InitializationStageImpl = class {
+  constructor() {
+    this.id = "stage_initialization";
+    this.name = "Initializing" /* Initializing */;
+    this.description = "Subsystem Kernels initialization";
+  }
+  async execute(context) {
+    context.setStage("Initializing" /* Initializing */);
+  }
+};
+var ActivationStageImpl = class {
+  constructor() {
+    this.id = "stage_activation";
+    this.name = "Activating" /* Activating */;
+    this.description = "Plugin Host discovery & ESM plugins activation";
+  }
+  async execute(context) {
+    context.setStage("Activating" /* Activating */);
+  }
+};
+var ReadyStageImpl = class {
+  constructor() {
+    this.id = "stage_ready";
+    this.name = "Ready" /* Ready */;
+    this.description = "HTTP & Socket.IO server readiness";
+  }
+  async execute(context) {
+    context.setStage("Ready" /* Ready */);
+  }
+};
 
-  function post(msg) {
-    if (window.parent && window.parent !== window) {
-      window.parent.postMessage(Object.assign({ channel: CHANNEL }, msg), targetOrigin);
+// packages/core/bootstrap/pipeline/bootstrap-pipeline.ts
+var BootstrapPipeline = class {
+  constructor(stages) {
+    this._stages = [];
+    this.executor = new PipelineExecutor();
+    if (stages && stages.length > 0) {
+      this._stages = [...stages];
+    } else {
+      this._stages = [
+        new StartupStageImpl(),
+        new RegistrationStageImpl(),
+        new InitializationStageImpl(),
+        new ActivationStageImpl(),
+        new ReadyStageImpl()
+      ];
     }
   }
-
-  function call(op, args) {
-    const callId = Math.random().toString(16).slice(2) + Date.now().toString(16);
-    return new Promise(function (resolve, reject) {
-      pending.set(callId, { resolve: resolve, reject: reject });
-      post({ type: 'call', callId: callId, op: op, args: args || [] });
-    });
+  get stages() {
+    return Object.freeze(this._stages);
+  }
+  addStage(stage) {
+    this._stages.push(stage);
+    return this;
+  }
+  addListener(listener) {
+    return this.executor.addListener(listener);
   }
+  async run(context) {
+    const result = await this.execute(context);
+    if (result.status === "Failed") {
+      throw result.error || new Error(`Bootstrap Pipeline failed at stage: ${result.failedStage}`);
+    }
+  }
+  async execute(context) {
+    return this.executor.execute(this._stages, context);
+  }
+};
 
-  window.addEventListener('message', function (event) {
-    const data = event.data;
-    if (!data || data.channel !== CHANNEL) return;
-    if (event.source !== window.parent) return;
+// packages/core/bootstrap/builder/builder-validation-engine.ts
+var BuilderValidationEngine = class {
+  static validate(config, environment, stages) {
+    const errors = [];
+    const warnings = [];
+    if (!["development", "production", "test"].includes(environment)) {
+      errors.push({
+        code: "INVALID_ENVIRONMENT",
+        message: `Environment must be one of 'development', 'production', 'test'. Received: '${environment}'`,
+        field: "environment"
+      });
+    }
+    if (!config.port || config.port <= 0 || config.port > 65535) {
+      errors.push({
+        code: "INVALID_PORT",
+        message: `Port must be a valid number between 1 and 65535. Received: ${config.port}`,
+        field: "port"
+      });
+    }
+    if (!stages || stages.length === 0) {
+      errors.push({
+        code: "MISSING_STAGES",
+        message: "Bootstrap pipeline contains no registered stages.",
+        field: "stages"
+      });
+    } else {
+      const stageIds = /* @__PURE__ */ new Set();
+      for (const stage of stages) {
+        if (!stage.id) {
+          errors.push({
+            code: "INVALID_STAGE",
+            message: `Stage '${stage.name}' has no unique ID.`
+          });
+        } else if (stageIds.has(stage.id)) {
+          errors.push({
+            code: "DUPLICATE_STAGE",
+            message: `Duplicate stage registration detected for stage ID '${stage.id}'.`,
+            field: "stage.id"
+          });
+        } else {
+          stageIds.add(stage.id);
+        }
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors: Object.freeze(errors),
+      warnings: Object.freeze(warnings)
+    };
+  }
+};
 
-    if (data.type === 'init') {
-      currentContext = data.payload || {};
-      targetOrigin = event.origin && event.origin !== 'null' ? event.origin : '*';
-      for (let i = 0; i < initCallbacks.length; i++) {
-        try {
-          initCallbacks[i](currentContext);
-        } catch (e) {
-          console.error('[OpenLearnPluginBridge] init callback error:', e);
+// packages/core/bootstrap/builder/platform-builder.ts
+var DefaultPlatformLogger = class {
+  info(message, ...args) {
+    console.log(`[PlatformBuilder:INFO] ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(`[PlatformBuilder:WARN] ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.error(`[PlatformBuilder:ERROR] ${message}`, ...args);
+  }
+  debug(message, ...args) {
+    console.debug(`[PlatformBuilder:DEBUG] ${message}`, ...args);
+  }
+};
+var PlatformBuilder = class _PlatformBuilder {
+  constructor(options) {
+    this._state = "Created";
+    this._config = { ...DEFAULT_BOOTSTRAP_CONFIG };
+    this._logger = new DefaultPlatformLogger();
+    this._environment = "development";
+    this._metadata = /* @__PURE__ */ new Map();
+    this._services = /* @__PURE__ */ new Map();
+    this._capabilities = /* @__PURE__ */ new Map();
+    this._extensions = /* @__PURE__ */ new Map();
+    this._pipeline = new BootstrapPipeline();
+    this._state = "Created";
+    this._logger.info("Builder Started");
+    if (options) {
+      if (options.config) this.withConfiguration(options.config);
+      if (options.logger) this.withLogger(options.logger);
+      if (options.environment) this.withEnvironment(options.environment);
+      if (options.metadata) {
+        for (const [k, v] of Object.entries(options.metadata)) {
+          this.withMetadata(k, v);
         }
       }
-      return;
     }
-
-    if (data.type === 'context-update') {
-      currentContext = Object.assign({}, currentContext, data.payload || {});
-      for (let i = 0; i < contextUpdateCallbacks.length; i++) {
-        try {
-          contextUpdateCallbacks[i](currentContext);
-        } catch (e) {
-          console.error('[OpenLearnPluginBridge] contextUpdate callback error:', e);
-        }
-      }
-      return;
+  }
+  static create(options) {
+    return new _PlatformBuilder(options);
+  }
+  get state() {
+    return this._state;
+  }
+  transitionTo(newState) {
+    if (this._state === "Disposed") {
+      throw new Error("PlatformBuilder has been disposed and cannot accept further transitions.");
     }
-
-    if (data.type === 'reply') {
-      const waiter = pending.get(data.callId);
-      if (!waiter) return;
-      pending.delete(data.callId);
-      if (data.ok) {
-        waiter.resolve(data.value);
-      } else {
-        waiter.reject(new Error(data.error || 'bridge call failed'));
-      }
-      return;
+    if (this._state === "Built" && newState !== "Disposed") {
+      throw new Error(`Invalid state transition from Built to ${newState}. Builder is already built.`);
     }
-  });
-
-  const bridge = {
-    CHANNEL: CHANNEL,
-    onInit: function (callback) {
-      if (typeof callback === 'function') {
-        if (currentContext) {
-          try {
-            callback(currentContext);
-          } catch (e) {
-            console.error('[OpenLearnPluginBridge] onInit callback error:', e);
-          }
-        }
-        initCallbacks.push(callback);
-      }
-      return bridge;
-    },
-    onContextUpdate: function (callback) {
-      if (typeof callback === 'function') {
-        contextUpdateCallbacks.push(callback);
-      }
-      return bridge;
-    },
-    getContext: function () {
-      return currentContext;
-    },
-    ui: {
-      toast: function (message, type) {
-        return call('ui.toast', [message, type || 'info']);
+    this._state = newState;
+  }
+  withConfiguration(config) {
+    this.transitionTo("Configuring");
+    this._config = { ...this._config, ...config };
+    if (config.environment) {
+      this._environment = config.environment;
+    }
+    this._logger.info("Configuration Loaded");
+    return this;
+  }
+  withLogger(logger2) {
+    this.transitionTo("Configuring");
+    this._logger = logger2;
+    return this;
+  }
+  withEnvironment(env) {
+    this.transitionTo("Configuring");
+    this._environment = env;
+    this._config = { ...this._config, environment: env };
+    return this;
+  }
+  withMetadata(key, value) {
+    this.transitionTo("Configuring");
+    this._metadata.set(key, value);
+    return this;
+  }
+  addBootstrapStage(stage) {
+    this.transitionTo("Configuring");
+    this._pipeline.addStage(stage);
+    return this;
+  }
+  addService(serviceId, instance) {
+    this.transitionTo("Configuring");
+    this._services.set(serviceId, instance);
+    return this;
+  }
+  addCapability(capabilityId, descriptor) {
+    this.transitionTo("Configuring");
+    this._capabilities.set(capabilityId, descriptor);
+    return this;
+  }
+  addExtension(extensionId, extensionSpec) {
+    this.transitionTo("Configuring");
+    this._extensions.set(extensionId, extensionSpec);
+    return this;
+  }
+  buildResult() {
+    const buildStart = Date.now();
+    this.transitionTo("Validating");
+    this._logger.info("Validation Started");
+    const validation = BuilderValidationEngine.validate(this._config, this._environment, this._pipeline.stages);
+    this._logger.info("Validation Completed");
+    if (!validation.isValid) {
+      this._logger.error(`Validation Failed with ${validation.errors.length} errors.`);
+      throw new ConfigurationError(
+        `PlatformBuilder validation failed: ${validation.errors.map((e) => e.message).join("; ")}`
+      );
+    }
+    this.transitionTo("Building");
+    this._logger.info("Build Started");
+    const platformContext = {
+      platformId: `plt_${globalThis.crypto.randomUUID()}`,
+      version: PLATFORM_VERSION2,
+      namespace: "openlearn.core",
+      mode: this._config.mode,
+      environment: {
+        type: this._environment,
+        isDevelopment: this._environment === "development",
+        isProduction: this._environment === "production",
+        isTest: this._environment === "test",
+        isPluginSandbox: false
       },
-      showToast: function (message, type) {
-        return call('ui.toast', [message, type || 'info']);
+      config: this._config,
+      featureFlags: {
+        isEnabled: () => true,
+        getFlag: (_, def) => def,
+        getAllFlags: () => ({})
       },
-      resize: function (height) {
-        post({ type: 'resize', height: Number(height) || 0 });
+      runtimeMetadata: {
+        os: process.platform,
+        nodeVersion: process.version,
+        arch: process.arch,
+        processId: process.pid,
+        memoryUsage: process.memoryUsage(),
+        buildVersion: PLATFORM_VERSION2
       },
-    },
-    invokeCommand: function (type, payload) {
-      return call('command.invoke', [type, payload]);
-    },
-    api: {
-      get: function (path) {
-        return call('api.get', [path]);
+      bootstrapState: "Bootstrapping",
+      logger: this._logger,
+      diagnostics: {
+        getMetrics: () => ({ uptime: 0 }),
+        getSystemStatus: () => ({ isHealthy: true, activeServicesCount: this._services.size, uptimeSeconds: 0 })
       },
-      post: function (path, body) {
-        return call('api.post', [path, body]);
+      serviceLocator: {
+        hasService: (id) => this._services.has(id),
+        getService: (id) => this._services.get(id)
       },
-      del: function (path) {
-        return call('api.del', [path]);
+      capabilityCatalog: {
+        hasCapability: (id) => this._capabilities.has(id),
+        getCapability: (id) => this._capabilities.get(id)
       },
-    },
-    storage: {
-      get: function (key) {
-        return call('storage.get', [key]);
+      extensionCatalog: {
+        hasExtension: (id) => this._extensions.has(id),
+        getExtension: (id) => this._extensions.get(id)
       },
-      set: function (key, value) {
-        return call('storage.set', [key, value]);
+      eventDispatcher: {
+        dispatch: async () => {
+        }
       },
-      delete: function (key) {
-        return call('storage.delete', [key]);
+      shutdownToken: {
+        isRequested: false,
+        onShutdown: () => {
+        }
+      }
+    };
+    const buildDurationMs = Date.now() - buildStart;
+    this.transitionTo("Built");
+    this._logger.info(`Build Completed in ${buildDurationMs} ms`);
+    const result = {
+      platformContext,
+      pipeline: this._pipeline,
+      buildDurationMs,
+      validation,
+      metadata: Object.fromEntries(this._metadata.entries()),
+      builderVersion: PLATFORM_VERSION2
+    };
+    return result;
+  }
+  async build() {
+    const res = this.buildResult();
+    return {
+      currentStage: "Created" /* Created */,
+      context: res.platformContext,
+      pipeline: res.pipeline,
+      start: async () => {
       },
-    },
-  };
-
-  window.OpenLearnPluginBridge = bridge;
-  // \u901A\u77E5\u5BBF\u4E3B\u89C6\u56FE\u6C99\u7BB1 iframe \u5DF2\u5C31\u7EEA
-  post({ type: 'ready' });
-})();
-`;
+      shutdown: async () => {
+      },
+      dispose: async () => {
+      }
+    };
+  }
+  async start() {
+    const kernel = await this.build();
+    await kernel.start();
+    return kernel;
+  }
+  async shutdown() {
+    this.transitionTo("Disposed");
+  }
+  dispose() {
+    this._state = "Disposed";
+    this._services.clear();
+    this._capabilities.clear();
+    this._extensions.clear();
+    this._metadata.clear();
+  }
+};
 
 // packages/core/bootstrap/adapter/bootstrap-registration.ts
 var BootstrapRegistration = class {