@makaio/framework 1.0.0-dev-1781022866275 → 1.0.0-dev-1781023871421

package/dist/index-B80L4YqA.d.mts

@@ -0,0 +1,180 @@
+//#region core/contracts/src/common/focus-context.d.ts
+/**
+ * Shared focus context type for navigation results.
+ *
+ * This type is used across multiple packages to define focus contexts
+ * for the web/app surface. It's centralized here to avoid duplication.
+ * @packageDocumentation
+ */
+/**
+ * Focus context types for navigation results.
+ *
+ * Represents the different focus areas available in the web/app interface.
+ * Used by slash commands, navigation results, and the focus store.
+ *
+ * The focus store implementation is in `@makaio/ui-hooks`.
+ */
+type FocusContext = 'chat' | 'git' | 'review' | 'planning' | 'settings';
+//#endregion
+//#region core/contracts/src/common/action-intent.d.ts
+/**
+ * Describes a UI side effect that an action handler intends to produce.
+ *
+ * Action handlers return an `ActionIntent` rather than executing effects directly.
+ * The framework's intent executor interprets and dispatches each kind.
+ *
+ * SEAM: New intent kinds are added here. UI executors add the corresponding
+ * cases without leaking renderer dependencies into service packages.
+ * @example
+ * ```typescript
+ * const intent: ActionIntent = { kind: 'clipboard', text: commit.hash };
+ * const compound: ActionIntent = {
+ *   kind: 'compound',
+ *   intents: [
+ *     { kind: 'clipboard', text: commit.hash },
+ *     { kind: 'feedback', message: 'Hash copied', variant: 'success' },
+ *   ],
+ * };
+ * ```
+ */
+type ActionIntent = {
+  readonly kind: 'noop';
+} | {
+  readonly kind: 'clipboard';
+  readonly text: string;
+  readonly feedback?: string;
+} | {
+  readonly kind: 'navigate';
+  readonly target: FocusContext;
+} | {
+  readonly kind: 'openEditor';
+  readonly filePath: string;
+  readonly line?: number;
+  readonly column?: number;
+} | {
+  readonly kind: 'openPage';
+  readonly pageId: string;
+  readonly internalRoute?: string;
+} | {
+  readonly kind: 'busRequest';
+  readonly subject: string;
+  readonly payload?: Record<string, unknown>;
+} | {
+  readonly kind: 'feedback';
+  readonly message: string;
+  readonly variant?: 'info' | 'success' | 'warning' | 'error';
+} | {
+  readonly kind: 'confirm';
+  readonly title: string;
+  readonly message: string;
+  readonly onConfirmIntent: ActionIntent;
+} | {
+  readonly kind: 'compound';
+  readonly intents: readonly ActionIntent[];
+}
+/**
+ * Open a diff view for a file.
+ *
+ * - `commitId` is `null` for working-tree diffs (right side is read from disk).
+ * - `status` is the git file status character (A/M/D/R/…) for commit contexts.
+ * - `parentCount` drives empty-tree handling for root commits.
+ * - `originalPath` carries the rename origin when the file was renamed.
+ * - `variant` is the working-tree section ('staged' | 'unstaged' | 'untracked' | 'conflicted').
+ */
+| {
+  readonly kind: 'viewDiff';
+  readonly filePath: string;
+  readonly commitId: string | null;
+  readonly status?: string;
+  readonly parentCount?: number;
+  readonly originalPath?: string;
+  readonly variant?: string;
+}
+/**
+ * Show file content at a specific commit in the inline file viewer panel.
+ * Only valid for commit-context files.
+ */
+| {
+  readonly kind: 'viewAtCommit';
+  readonly filePath: string;
+  readonly commitId: string;
+}
+/**
+ * Show blame annotations for a file at a specific commit in the inline blame panel.
+ * Only valid for commit-context files.
+ */
+| {
+  readonly kind: 'viewBlame';
+  readonly filePath: string;
+  readonly commitId: string;
+}
+/**
+ * Compare a file across revisions using the diff viewer.
+ *
+ * Equivalent to `viewDiff` but with `useEmptyTreeForRoot = true` — root commits
+ * are shown as full-add diffs against the empty tree. For working-tree contexts,
+ * untracked files are silently skipped.
+ *
+ * - `commitId` is `null` for working-tree compare.
+ * - `status`, `parentCount`, `originalPath`, `variant` carry the same semantics as `viewDiff`.
+ */
+| {
+  readonly kind: 'compareVersions';
+  readonly filePath: string;
+  readonly commitId: string | null;
+  readonly status?: string;
+  readonly parentCount?: number;
+  readonly originalPath?: string;
+  readonly variant?: string;
+};
+//#endregion
+//#region core/contracts/src/common/surface.d.ts
+/**
+ * Surface type definitions shared across all packages.
+ *
+ * These are the canonical surface types used throughout the system.
+ * Both the contracts-level page metadata and the framework-level
+ * page definitions reference these types.
+ * @packageDocumentation
+ */
+/**
+ * Rendering surface identifiers.
+ *
+ * Each surface represents a distinct runtime environment:
+ * - 'web': Browser-based React DOM rendering
+ * - 'mobile': React Native rendering (iOS/Android)
+ * - 'electron': Desktop Electron rendering (superset of web)
+ * - 'electrobun': Desktop Electrobun rendering (Bun-native alternative to Electron)
+ * - 'tray': Lightweight tray popover canvas (subset of desktop)
+ *
+ * SEAM: New surfaces can be added here as the platform expands.
+ */
+type SurfaceType = 'web' | 'mobile' | 'electron' | 'electrobun' | 'tray';
+/**
+ * Page surface visibility configuration.
+ *
+ * Controls which rendering surfaces a page appears on:
+ * - `'all'`: Available on every surface (default when omitted)
+ * - `SurfaceType[]`: Restricted to listed surfaces only
+ * @example
+ * ```typescript
+ * // Available everywhere
+ * surfaces: 'all'
+ *
+ * // Web and electron only
+ * surfaces: ['web', 'electron']
+ *
+ * // Mobile only
+ * surfaces: ['mobile']
+ * ```
+ */
+type SurfaceVisibility = 'all' | SurfaceType[];
+/**
+ * Check if a page is visible on a given surface.
+ * @param visibility - Page surface visibility configuration
+ * @param surface - Surface to check against
+ * @returns True if the page should be visible on the surface
+ */
+declare function isSurfaceVisible(visibility: SurfaceVisibility | undefined, surface: SurfaceType): boolean;
+//#endregion
+export { FocusContext as a, ActionIntent as i, SurfaceVisibility as n, isSurfaceVisible as r, SurfaceType as t };

package/dist/index-BFg9BUpx.d.mts

@@ -0,0 +1,355 @@
+import { z } from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+
+//#region core/contracts/src/materialization/namespace.d.ts
+/**
+ * Framework-level materialization bus schemas.
+ *
+ * Defines the RPC and event subjects for framework-level materialization
+ * coordination.
+ * The schema set covers:
+ *
+ * - `surfaceBinding.register` — register a surface binding with the registry (RPC)
+ * - `surfaceBinding.list` — query registered surface bindings (RPC)
+ * - `surfaceBinding.changed` — emitted when a surface binding is added (event)
+ * - `ref.changed` — emitted when a provider materialization ref changes (event)
+ * - `capability.resolved` — emitted when a provider surface capability set is resolved (event)
+ *
+ * Product hosts that extend the framework materialization surface should
+ * register a product-owned namespace rather than merging additional subjects
+ * into this one.
+ */
+declare const MaterializationSchemas: {
+  /**
+   * Register a surface binding with the surface binding registry (RPC).
+   * Returns `{ registered: true }` when successfully stored.
+   */
+  'surfaceBinding.register': {
+    request: z.ZodObject<{
+      id: z.ZodString;
+      provider: z.ZodString;
+      namespace: z.ZodString;
+      target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"label">;
+        prefix: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"field">;
+        name: z.ZodString;
+        fieldId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"issue-type">;
+        name: z.ZodString;
+        typeId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"body-fragment">;
+        slot: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"comment">;
+        template: z.ZodString;
+      }, z.core.$strip>], "kind">;
+      appliesTo: z.ZodArray<z.ZodEnum<{
+        surface: "surface";
+        workpiece: "workpiece";
+        artifact: "artifact";
+      }>>;
+      valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      registered: z.ZodBoolean;
+    }, z.core.$strip>;
+  }; /** List registered surface bindings, optionally filtered by provider or namespace (RPC). */
+  'surfaceBinding.list': {
+    request: z.ZodObject<{
+      provider: z.ZodOptional<z.ZodString>;
+      namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      bindings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        namespace: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"label">;
+          prefix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"field">;
+          name: z.ZodString;
+          fieldId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"issue-type">;
+          name: z.ZodString;
+          typeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"body-fragment">;
+          slot: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"comment">;
+          template: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        appliesTo: z.ZodArray<z.ZodEnum<{
+          surface: "surface";
+          workpiece: "workpiece";
+          artifact: "artifact";
+        }>>;
+        valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }; /** Emitted when a surface binding registration is added. */
+  'surfaceBinding.changed': z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+  }, z.core.$strip>; /** Emitted when a provider materialization ref is upserted or deleted. */
+  'ref.changed': z.ZodObject<{
+    artifactId: z.ZodString;
+    provider: z.ZodString;
+    externalId: z.ZodString;
+    operation: z.ZodEnum<{
+      deleted: "deleted";
+      upserted: "upserted";
+    }>;
+  }, z.core.$strip>; /** Emitted when a provider surface capability set has been resolved. */
+  'capability.resolved': z.ZodObject<{
+    provider: z.ZodString;
+    surface: z.ZodString;
+    capabilities: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    degraded: z.ZodBoolean;
+  }, z.core.$strip>;
+};
+/**
+ * Materialization bus namespace.
+ *
+ * Registers the `materialization` namespace with framework-level RPC and event
+ * subjects. Use `MaterializationSubjects` to access typed bus subject
+ * descriptors.
+ */
+declare const MaterializationNamespace: _$_makaio_core0.BusNamespaceDefinition<"materialization", {
+  /**
+   * Register a surface binding with the surface binding registry (RPC).
+   * Returns `{ registered: true }` when successfully stored.
+   */
+  'surfaceBinding.register': {
+    request: z.ZodObject<{
+      id: z.ZodString;
+      provider: z.ZodString;
+      namespace: z.ZodString;
+      target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"label">;
+        prefix: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"field">;
+        name: z.ZodString;
+        fieldId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"issue-type">;
+        name: z.ZodString;
+        typeId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"body-fragment">;
+        slot: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"comment">;
+        template: z.ZodString;
+      }, z.core.$strip>], "kind">;
+      appliesTo: z.ZodArray<z.ZodEnum<{
+        surface: "surface";
+        workpiece: "workpiece";
+        artifact: "artifact";
+      }>>;
+      valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      registered: z.ZodBoolean;
+    }, z.core.$strip>;
+  }; /** List registered surface bindings, optionally filtered by provider or namespace (RPC). */
+  'surfaceBinding.list': {
+    request: z.ZodObject<{
+      provider: z.ZodOptional<z.ZodString>;
+      namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      bindings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        namespace: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"label">;
+          prefix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"field">;
+          name: z.ZodString;
+          fieldId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"issue-type">;
+          name: z.ZodString;
+          typeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"body-fragment">;
+          slot: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"comment">;
+          template: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        appliesTo: z.ZodArray<z.ZodEnum<{
+          surface: "surface";
+          workpiece: "workpiece";
+          artifact: "artifact";
+        }>>;
+        valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }; /** Emitted when a surface binding registration is added. */
+  'surfaceBinding.changed': z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+  }, z.core.$strip>; /** Emitted when a provider materialization ref is upserted or deleted. */
+  'ref.changed': z.ZodObject<{
+    artifactId: z.ZodString;
+    provider: z.ZodString;
+    externalId: z.ZodString;
+    operation: z.ZodEnum<{
+      deleted: "deleted";
+      upserted: "upserted";
+    }>;
+  }, z.core.$strip>; /** Emitted when a provider surface capability set has been resolved. */
+  'capability.resolved': z.ZodObject<{
+    provider: z.ZodString;
+    surface: z.ZodString;
+    capabilities: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    degraded: z.ZodBoolean;
+  }, z.core.$strip>;
+}>;
+/**
+ * Typed subjects for materialization bus communication.
+ *
+ * Available subjects:
+ * - `MaterializationSubjects['surfaceBinding.register']` — register a surface binding (RPC)
+ * - `MaterializationSubjects['surfaceBinding.list']` — list surface bindings (RPC)
+ * - `MaterializationSubjects['surfaceBinding.changed']` — binding changed event
+ * - `MaterializationSubjects['ref.changed']` — materialization ref changed event
+ * - `MaterializationSubjects['capability.resolved']` — provider capability resolved event
+ *
+ * Nested shorthand (via dot-segment nesting):
+ * - `MaterializationSubjects.surfaceBinding.register` — register (RPC)
+ * - `MaterializationSubjects.surfaceBinding.list` — list (RPC)
+ * - `MaterializationSubjects.surfaceBinding.changed` — changed event
+ * - `MaterializationSubjects.ref.changed` — ref changed event
+ * - `MaterializationSubjects.capability.resolved` — capability resolved event
+ */
+declare const MaterializationSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"materialization", {
+  /**
+   * Register a surface binding with the surface binding registry (RPC).
+   * Returns `{ registered: true }` when successfully stored.
+   */
+  'surfaceBinding.register': {
+    request: z.ZodObject<{
+      id: z.ZodString;
+      provider: z.ZodString;
+      namespace: z.ZodString;
+      target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"label">;
+        prefix: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"field">;
+        name: z.ZodString;
+        fieldId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"issue-type">;
+        name: z.ZodString;
+        typeId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"body-fragment">;
+        slot: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"comment">;
+        template: z.ZodString;
+      }, z.core.$strip>], "kind">;
+      appliesTo: z.ZodArray<z.ZodEnum<{
+        surface: "surface";
+        workpiece: "workpiece";
+        artifact: "artifact";
+      }>>;
+      valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      registered: z.ZodBoolean;
+    }, z.core.$strip>;
+  }; /** List registered surface bindings, optionally filtered by provider or namespace (RPC). */
+  'surfaceBinding.list': {
+    request: z.ZodObject<{
+      provider: z.ZodOptional<z.ZodString>;
+      namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      bindings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        namespace: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"label">;
+          prefix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"field">;
+          name: z.ZodString;
+          fieldId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"issue-type">;
+          name: z.ZodString;
+          typeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"body-fragment">;
+          slot: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"comment">;
+          template: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        appliesTo: z.ZodArray<z.ZodEnum<{
+          surface: "surface";
+          workpiece: "workpiece";
+          artifact: "artifact";
+        }>>;
+        valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }; /** Emitted when a surface binding registration is added. */
+  'surfaceBinding.changed': z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+  }, z.core.$strip>; /** Emitted when a provider materialization ref is upserted or deleted. */
+  'ref.changed': z.ZodObject<{
+    artifactId: z.ZodString;
+    provider: z.ZodString;
+    externalId: z.ZodString;
+    operation: z.ZodEnum<{
+      deleted: "deleted";
+      upserted: "upserted";
+    }>;
+  }, z.core.$strip>; /** Emitted when a provider surface capability set has been resolved. */
+  'capability.resolved': z.ZodObject<{
+    provider: z.ZodString;
+    surface: z.ZodString;
+    capabilities: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    degraded: z.ZodBoolean;
+  }, z.core.$strip>;
+}>, "materialization">;
+/** Request payload for registering a surface binding. */
+type SurfaceBindingRegisterRequest = z.infer<(typeof MaterializationSchemas)['surfaceBinding.register']['request']>;
+/** Response payload for registering a surface binding. */
+type SurfaceBindingRegisterResponse = z.infer<(typeof MaterializationSchemas)['surfaceBinding.register']['response']>;
+/** Request payload for listing surface bindings. */
+type SurfaceBindingListRequest = z.infer<(typeof MaterializationSchemas)['surfaceBinding.list']['request']>;
+/** Response payload for listing surface bindings. */
+type SurfaceBindingListResponse = z.infer<(typeof MaterializationSchemas)['surfaceBinding.list']['response']>;
+/** Payload for the surface binding changed event. */
+type SurfaceBindingChangedPayload = z.infer<(typeof MaterializationSchemas)['surfaceBinding.changed']>;
+/** Payload for the materialization ref changed event. */
+type MaterializationRefChangedPayload = z.infer<(typeof MaterializationSchemas)['ref.changed']>;
+/** Payload for the materialization capability resolved event. */
+type MaterializationCapabilityResolvedPayload = z.infer<(typeof MaterializationSchemas)['capability.resolved']>;
+//#endregion
+export { MaterializationSubjects as a, SurfaceBindingListResponse as c, MaterializationSchemas as i, SurfaceBindingRegisterRequest as l, MaterializationNamespace as n, SurfaceBindingChangedPayload as o, MaterializationRefChangedPayload as r, SurfaceBindingListRequest as s, MaterializationCapabilityResolvedPayload as t, SurfaceBindingRegisterResponse as u };