@punica/editor 1.5.0 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Punica Editor",
   "private": false,
   "type": "module",

package/types/index.d.ts

@@ -132,4 +132,135 @@ export function bootstrap(options?: {
  */
 export function start(): Promise<void>;
 
+// ---------------------------------------------------------------------------
+// Headless seam + substrate re-exports.
+//
+// These are the `@punica/editor` package's runtime exports consumed by an
+// external shell package (`@punica/editor-shell-classic`) built as its own
+// bundle with `@punica/editor` marked external. The corresponding runtime
+// values live in `src/index.ts` (re-exported from `src/impl/core/*`).
+
+/** Module lifecycle states (mirrors `core/moduleTypes.ts`). */
+export enum ModuleLifecycleState {
+  CREATED = 'created',
+  BOOTSTRAPPING = 'bootstrapping',
+  BOOTSTRAPPED = 'bootstrapped',
+  BOOTSTRAP_FAILED = 'bootstrap_failed',
+  STARTING = 'starting',
+  STARTED = 'started',
+  START_FAILED = 'start_failed',
+  READY = 'ready'
+}
+
+/** Module registry surface reachable from a module's lifecycle context. */
+export interface IModuleRegistry {
+  register(module: IModule): void;
+  get(name: string): IModule | undefined;
+  getAll(): readonly IModule[];
+  resolveBootstrapOrder(): string[];
+  resolveStartOrder(): string[];
+  bootstrapAll(): Promise<void>;
+  startAll(): Promise<void>;
+  getState(moduleName: string): ModuleLifecycleState | undefined;
+  areAllModulesReady(): boolean;
+  detectPreBootstrapAccess(): string[];
+}
+
+/** Context passed to module lifecycle methods. */
+export interface ModuleContext {
+  readonly phase: 'bootstrap' | 'start';
+  readonly punica: typeof import('punica');
+  readonly registry: IModuleRegistry;
+}
+
+/** Core module interface all Punica modules implement. */
+export interface IModule {
+  readonly name: string;
+  readonly version: string;
+  readonly dependencies: readonly string[];
+  readonly state: ModuleLifecycleState;
+  bootstrap(context: ModuleContext): Promise<void>;
+  start(context: ModuleContext): Promise<void>;
+}
+
+/** A shell contribution registered via `registerShell()`. */
+export interface ShellContribution {
+  facade?: Record<string, unknown>;
+  moduleFactories?: Record<string, () => IModule>;
+  profiles?: import('punica').shell.Profile.ApplicationProfile[];
+  defaultProfileId?: string;
+}
+
+/**
+ * Register a shell contribution (facade, profile-gated modules, profiles).
+ * Call after `initialize()` and before `bootstrap()`. Multiple calls
+ * accumulate.
+ */
+export function registerShell(contribution: ShellContribution): void;
+
+/** Centralized module-name constants (`MODULE_NAMES.SHELL.LAYOUT`, …). */
+export const MODULE_NAMES: {
+  readonly [group: string]: { readonly [key: string]: string };
+};
+
+/** Centralized command-id constants (`COMMAND_IDS.WORKFLOW.RUN_START`, …). */
+export const COMMAND_IDS: {
+  readonly [group: string]: { readonly [key: string]: string };
+};
+
+/** True when running on a Mac platform (affects key-chord parsing). */
+export function isMacPlatform(): boolean;
+
+/** Parse a `'mod+shift+p'`-style chord into an `IKey`. */
+export function parseKeyChord(
+  chord: string,
+  isMac?: boolean
+): import('punica').shell.KeyboardShortcuts.IKey;
+
+/** True while executing inside a headless UI-activation scope. */
+export function isHeadlessScope(): boolean;
+
+/** Enter a headless UI-activation scope (view reveals materialize hidden). */
+export function enterHeadlessScope(): void;
+
+/** Exit the current headless UI-activation scope. */
+export function exitHeadlessScope(): void;
+
+/** Run `fn` inside a headless UI-activation scope, restoring the prior scope. */
+export function runInHeadlessScope<T>(fn: () => Promise<T>): Promise<T>;
+
+/** Options for `emitShellEvent()`. */
+export interface ShellEventOptions {
+  name: string;
+  source?: string;
+  correlationId?: string;
+  traceId?: string;
+  kind?: 'info' | 'warn' | 'error';
+  payload: Record<string, unknown>;
+}
+
+/** Best-effort kernel-event emit from the shell/profile layer. */
+export function emitShellEvent(opts: ShellEventOptions): boolean;
+
+/** The core-owned ApplicationProfile mechanism (`punica.shell.Profile`). */
+export const Profile: {
+  readonly manager: import('punica').shell.Profile.IProfileManager;
+};
+
+/** ApplicationProfile validator interface (host-injectable). */
+export interface IProfileValidator {
+  validate(data: unknown):
+    | {
+        valid: true;
+        profile: import('punica').shell.Profile.ApplicationProfile;
+      }
+    | { valid: false; errors: string[] };
+}
+
+/** Returns the injected validator if set, else the minimal default. */
+export function getProfileValidator(): IProfileValidator;
+
+/** Inject a production-grade (e.g. Ajv-backed) profile validator. */
+export function setProfileValidator(v: IProfileValidator): void;
+
 export {};

package/types/punica.module.extensions.api.d.ts

@@ -57,6 +57,15 @@ declare module 'punica' {
          * panel view. Ignored by older cores.
          */
         toolbar?: PanelToolbarAction[];
+        /**
+         * When `false`, the tab is ON-DEMAND: no tab is added at load
+         * time. The placement is still registered, so the owning
+         * extension reveals the view (`context.ui.reveal`) when the
+         * relevant activity begins — reveal creates the tab — and hides
+         * it (`context.ui.hide`) when done, which removes the tab.
+         * Defaults to `true` (tab present at load). Ignored by older cores.
+         */
+        showOnStartup?: boolean;
       };
       activityBar?: Pick<BaseView, 'id' | 'name'> &
         Required<Pick<BaseView, 'title' | 'icon' | 'alignment'>>;

package/types/punica.module.shell.panelTabs.d.ts

@@ -39,7 +39,12 @@ declare module 'punica' {
         toolbar?: PanelToolbarAction[];
       }): void;
 
-      close(id: string): void;
+      /**
+       * Remove a tab from the strip. `silent: true` removes it without
+       * promoting a sibling to active — used when hiding an on-demand
+       * panel (the ViewRegistry collapses the slot separately).
+       */
+      close(id: string, options?: { silent?: boolean }): void;
       closeAll(): void;
 
       /** Returns the id of the currently active panel tab, or null. */