@crewx/sdk 0.9.0-rc.8 → 0.9.0-rc.80

package/dist/ui-card/index.d.ts

@@ -0,0 +1,2 @@
+export { extractLegacyWorkflowRunId, scanLegacyUiCardAt, scanLegacyUiCardTags, } from './legacy-card-parser';
+export type { LegacyUiCardTag } from './legacy-card-parser';

package/dist/ui-card/legacy-card-parser.d.ts

@@ -0,0 +1,11 @@
+export interface LegacyUiCardTag {
+    start: number;
+    end: number;
+    raw: string;
+    closed: boolean;
+    attrs: Readonly<Record<string, string>>;
+    privileged: boolean;
+}
+export declare function scanLegacyUiCardAt(text: string, start: number): LegacyUiCardTag;
+export declare function scanLegacyUiCardTags(text: string): LegacyUiCardTag[];
+export declare function extractLegacyWorkflowRunId(text: string | null | undefined): string | undefined;

package/dist/ui-instance/definition.d.ts

@@ -0,0 +1,6 @@
+import type { UiDefinition, UiDefinitionInput, UiDefinitionRef } from './types.js';
+export declare function hashUiDefinition(input: UiDefinitionInput): string;
+export declare function definitionKey(ref: UiDefinitionRef): string;
+export declare function validateDefinition(definition: UiDefinition): void;
+export declare function isExactCapability(value: string): boolean;
+export declare function refFromDefinition(definition: UiDefinition): UiDefinitionRef;

package/dist/ui-instance/errors.d.ts

@@ -0,0 +1,17 @@
+export type UiRuntimeErrorCode = 'UNAUTHENTICATED' | 'INSTANCE_NOT_FOUND' | 'WORKSPACE_MISMATCH' | 'INSTANCE_NOT_ACTIONABLE' | 'DEFINITION_UNSUPPORTED' | 'CAPABILITY_DENIED' | 'INPUT_INVALID' | 'REVISION_CONFLICT' | 'ACTION_UNAVAILABLE' | 'HANDLER_NOT_FOUND' | 'ACTION_IN_FLIGHT' | 'DOMAIN_REJECTED' | 'EXECUTION_FAILED';
+export declare class UiRuntimeError extends Error {
+    readonly code: UiRuntimeErrorCode;
+    readonly currentRevision?: number | undefined;
+    readonly name = "UiRuntimeError";
+    constructor(code: UiRuntimeErrorCode, message?: string, currentRevision?: number | undefined);
+}
+export declare class UiRetryableDatabaseError extends Error {
+    readonly cause: unknown;
+    readonly name = "UiRetryableDatabaseError";
+    constructor(cause: unknown);
+}
+export declare class UiReservationConflictError extends Error {
+    readonly currentRevision: number;
+    readonly name = "UiReservationConflictError";
+    constructor(currentRevision: number);
+}

package/dist/ui-instance/index.d.ts

@@ -0,0 +1,6 @@
+export type { ActionReceipt, ActionReceiptOutcome, CreateUiInstanceInput, JsonObject, JsonPrimitive, JsonValue, UiActionHandlerContext, UiActionHandlerRegistration, UiActionHandlerResult, UiActionEnvelope, UiActor, UiDefinition, UiDefinitionAction, UiDefinitionInput, UiDefinitionRef, UiProjectionPolicy, UiExecutionContext, UiAuthenticatedActor, UiAuthenticatedExecutionContext, UiAuthenticatedGrantPolicy, UiServerRuntimeFacade, UiServerRuntimeOptions, UiAgentContextProjection, UiExternalActionHandlerRegistration, UiInstance, UiInstanceStatus, UiLocalGrantPolicy, UiRuntimeFacade, UiRuntimeOptions, UiStateActionHandlerRegistration, } from './types.js';
+export { resolveUiEffectiveCapabilities } from './types.js';
+export { UiRuntimeError } from './errors.js';
+export type { UiRuntimeErrorCode } from './errors.js';
+export { hashUiDefinition } from './definition.js';
+export { createUiRuntimeForTest, createUiServerRuntime } from './runtime.js';

package/dist/ui-instance/json.d.ts

@@ -0,0 +1,5 @@
+import type { JsonObject, JsonValue } from './types.js';
+export declare function projectSafeJsonObject(value: unknown): JsonObject;
+export declare function serializeJson(value: JsonValue): string;
+export declare function canonicalJson(value: JsonValue): string;
+export declare function utf8ByteLength(value: string): number;

package/dist/ui-instance/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { UiRuntimeFacade, UiRuntimeOptions, UiServerRuntimeFacade, UiServerRuntimeOptions } from './types.js';
+export interface UiRuntimeTestHooks {
+    beforeReservation?: () => Promise<void> | void;
+    injectDatabaseError?: () => unknown | undefined;
+    bumpRevisionBeforeCas?: boolean;
+}
+export interface UiRuntimeForTestOptions extends UiRuntimeOptions {
+    workspaceId: string;
+    testHooks?: UiRuntimeTestHooks;
+}
+export declare function createUiRuntime(workspaceId: string, options: UiRuntimeOptions): UiRuntimeFacade;
+export declare function createUiRuntimeForTest(options: UiRuntimeForTestOptions): UiRuntimeFacade;
+export declare function createUiServerRuntime(options: UiServerRuntimeOptions): UiServerRuntimeFacade;

package/dist/ui-instance/store.d.ts

@@ -0,0 +1,65 @@
+import type { ActionReceipt, ActionReceiptOutcome, JsonObject, UiActionHandlerContext, UiActor, UiInstance } from './types.js';
+interface UiInstanceStoreTestHooks {
+    injectDatabaseError?: () => unknown | undefined;
+    bumpRevisionBeforeCas?: boolean;
+}
+export interface ReservationInput {
+    instanceId: string;
+    requestId: string;
+    actionId: string;
+    actor: UiActor;
+    source: 'cli' | 'ui_host' | 'system';
+    expectedRevision: number;
+    input: JsonObject;
+    now: number;
+}
+export interface StateHandlerExecution {
+    handle: (context: UiActionHandlerContext) => {
+        state?: JsonObject;
+        result?: JsonObject;
+    } | {
+        outcome: 'rejected' | 'failed';
+        errorCode: string;
+        state?: JsonObject;
+        result?: JsonObject;
+    };
+}
+export interface ExternalReservation {
+    instance: UiInstance;
+    receipt: ActionReceipt;
+    reservedRevision: number;
+}
+export declare class UiInstanceStore {
+    private readonly handle;
+    private readonly db;
+    private readonly testHooks?;
+    constructor(dbPath?: string, testHooks?: UiInstanceStoreTestHooks);
+    close(): void;
+    create(input: {
+        id: string;
+        definitionId: string;
+        definitionVersion: number;
+        definitionHash: string;
+        workspaceId: string;
+        threadId: string;
+        anchorTaskId: string | null;
+        domainRef: JsonObject;
+        state: JsonObject;
+        grants: readonly string[];
+        now: number;
+    }): UiInstance;
+    get(instanceId: string): UiInstance | null;
+    getReceipt(instanceId: string, requestId: string): ActionReceipt | null;
+    runStateOnly(reservation: ReservationInput, handler: StateHandlerExecution['handle']): ActionReceipt;
+    reserveExternal(reservation: ReservationInput): ExternalReservation;
+    settleExternal(input: {
+        reservation: ReservationInput;
+        reservedRevision: number;
+        outcome: ActionReceiptOutcome;
+        state: JsonObject;
+        result: JsonObject | null;
+        errorCode: string | null;
+        now: number;
+    }): ActionReceipt;
+}
+export {};

package/dist/ui-instance/types.d.ts

@@ -0,0 +1,200 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type UiInstanceStatus = 'active' | 'completed' | 'expired' | 'revoked' | 'unsupported';
+export interface UiDefinitionRef {
+    id: string;
+    version: number;
+    hash: string;
+}
+export interface UiDefinitionAction {
+    readonly capabilities: readonly string[];
+    readonly inputKeys?: readonly string[];
+    readonly resultProjection?: UiProjectionPolicy;
+}
+export interface UiProjectionPolicy {
+    allow: readonly string[];
+}
+export interface UiDefinitionInput {
+    readonly id: string;
+    readonly version: number;
+    readonly actions: Readonly<Record<string, UiDefinitionAction>>;
+    readonly renderer?: string;
+    readonly surfaces?: readonly string[];
+    readonly stateProjection?: UiProjectionPolicy;
+}
+export interface UiDefinition extends UiDefinitionInput {
+    readonly hash: string;
+}
+export interface CreateUiInstanceInput {
+    definition: UiDefinitionRef;
+    workspaceId: string;
+    threadId: string;
+    anchorTaskId?: string;
+    domainRef: JsonObject;
+    state: JsonObject;
+}
+export interface UiInstance {
+    id: string;
+    definition: UiDefinitionRef;
+    workspaceId: string;
+    threadId: string;
+    anchorTaskId: string | null;
+    domainRef: JsonObject;
+    state: JsonObject;
+    revision: number;
+    status: UiInstanceStatus;
+    grantedCapabilities: readonly string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface UiActionEnvelope {
+    instanceId: string;
+    actionId: string;
+    expectedRevision: number;
+    requestId: string;
+    input: JsonObject;
+}
+export type UiActor = {
+    kind: 'local';
+    id: string;
+} | {
+    kind: 'authenticated';
+    id: string;
+};
+export interface UiExecutionContext {
+    source: 'cli' | 'ui_host' | 'system';
+    workspaceId: string;
+    actor: UiActor;
+}
+export interface UiAuthenticatedActor {
+    kind: 'authenticated';
+    id: string;
+}
+export interface UiAuthenticatedExecutionContext {
+    source: 'ui_host' | 'system';
+    workspaceId: string;
+    threadId: string;
+    actor: UiAuthenticatedActor;
+}
+export type ActionReceiptOutcome = 'succeeded' | 'rejected' | 'failed' | 'conflicted' | 'expired';
+export interface ActionReceipt {
+    id: string;
+    instanceId: string;
+    requestId: string;
+    actionId: string;
+    actor: UiActor;
+    source: 'cli' | 'ui_host' | 'system';
+    expectedRevision: number;
+    beforeRevision: number;
+    afterRevision: number | null;
+    status: 'requested' | 'settled';
+    outcome: ActionReceiptOutcome | null;
+    input: JsonObject;
+    result: JsonObject | null;
+    errorCode: string | null;
+    requestedAt: number;
+    settledAt: number | null;
+}
+export interface UiLocalGrantPolicy {
+    resolveInstanceGrants(input: {
+        definition: UiDefinitionRef;
+        workspaceId: string;
+        actor: Extract<UiActor, {
+            kind: 'local';
+        }>;
+    }): readonly string[];
+    resolveActionCapabilities(input: {
+        definition: UiDefinitionRef;
+        actionId: string;
+    }): readonly string[];
+}
+export interface UiActionHandlerContext {
+    instance: UiInstance;
+    actor: UiActor;
+    source: 'cli' | 'ui_host' | 'system';
+    input: JsonObject;
+    requestId: string;
+}
+export type UiActionHandlerResult = {
+    state?: JsonObject;
+    result?: JsonObject;
+} | {
+    outcome: 'rejected' | 'failed';
+    errorCode: string;
+    state?: JsonObject;
+    result?: JsonObject;
+};
+export interface UiStateActionHandlerRegistration {
+    definitionId: string;
+    version: number;
+    actionId: string;
+    kind: 'state';
+    handle: (context: UiActionHandlerContext) => UiActionHandlerResult;
+}
+export interface UiExternalActionHandlerRegistration {
+    definitionId: string;
+    version: number;
+    actionId: string;
+    kind: 'external';
+    handle: (context: UiActionHandlerContext) => Promise<UiActionHandlerResult>;
+}
+export type UiActionHandlerRegistration = UiStateActionHandlerRegistration | UiExternalActionHandlerRegistration;
+export interface UiRuntimeOptions {
+    dbPath?: string;
+    localActor: Extract<UiActor, {
+        kind: 'local';
+    }>;
+    localGrantPolicy?: UiLocalGrantPolicy;
+    definitions?: readonly UiDefinition[];
+    handlers?: readonly UiActionHandlerRegistration[];
+    clock?: () => number;
+}
+export interface UiRuntimeFacade {
+    resolveDefinition(ref: UiDefinitionRef): UiDefinition | null;
+    createInstance(input: CreateUiInstanceInput): Promise<UiInstance>;
+    dispatchAction(input: UiActionEnvelope, context: UiExecutionContext): Promise<ActionReceipt>;
+    getReceipt(instanceId: string, requestId: string): Promise<ActionReceipt | null>;
+    close(): void;
+}
+export interface UiAuthenticatedGrantPolicy {
+    resolveInstanceGrants(input: {
+        definition: UiDefinitionRef;
+        workspaceId: string;
+        actor: UiAuthenticatedActor;
+    }): readonly string[];
+    resolveDispatchCapabilities?(input: {
+        definition: UiDefinitionRef;
+        actionId: string;
+        actor: UiAuthenticatedActor;
+        source: 'ui_host' | 'system';
+    }): readonly string[];
+}
+export declare function resolveUiEffectiveCapabilities(declared: readonly string[], instanceGranted: readonly string[], dispatchGranted?: readonly string[]): readonly string[];
+export interface UiServerRuntimeOptions {
+    workspaceId: string;
+    dbPath: string;
+    definitions: readonly UiDefinition[];
+    handlers: readonly UiActionHandlerRegistration[];
+    grantPolicy: UiAuthenticatedGrantPolicy;
+    clock?: () => number;
+}
+export interface UiServerRuntimeFacade {
+    resolveDefinition(ref: UiDefinitionRef): UiDefinition | null;
+    getInstance(instanceId: string, context: UiAuthenticatedExecutionContext): Promise<UiInstance | null>;
+    createInstance(input: CreateUiInstanceInput, context: UiAuthenticatedExecutionContext): Promise<UiInstance>;
+    dispatchAction(input: UiActionEnvelope, context: UiAuthenticatedExecutionContext): Promise<ActionReceipt>;
+    getReceipt(instanceId: string, requestId: string, context: UiAuthenticatedExecutionContext): Promise<ActionReceipt | null>;
+    close(): void;
+}
+export interface UiAgentContextProjection {
+    instanceId: string;
+    definition: UiDefinitionRef;
+    revision: number;
+    facts: JsonObject;
+    recentChanges: readonly JsonObject[];
+    pendingDecision: JsonObject | null;
+    availableActions: readonly string[];
+}

package/dist/ui-plugin/index.d.ts

@@ -0,0 +1,3 @@
+export { canonicalManifestJson, manifestHash } from './manifest.js';
+export { UiPluginValidationError, normalizeManifest, validateManifest, validatePayload, } from './validator.js';
+export type { UiPluginActivation, UiPluginCardShellNode, UiPluginFieldSchema, UiPluginHeadingNode, UiPluginLabeledTextNode, UiPluginLayoutNode, UiPluginLayout, UiPluginManifest, UiPluginMetaBannerNode, UiPluginPayload, UiPluginPayloadValue, UiPluginPrimitive, UiPluginSchemaType, UiPluginSchema, UiPluginStep, UiPluginStepFlowNode, UiPluginStepListSchema, UiPluginTextListNode, UiPluginTextListSchema, UiPluginTextSchema, UiPluginValidationErrorCode, UiPluginValidationOptions, } from './types.js';

package/dist/ui-plugin/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { UiPluginManifest } from './types.js';
+export declare function canonicalManifestJson(manifest: UiPluginManifest): string;
+export declare function manifestHash(manifest: UiPluginManifest): string;

package/dist/ui-plugin/types.d.ts

@@ -0,0 +1,76 @@
+export type UiPluginPrimitive = 'card-shell' | 'meta-banner' | 'heading' | 'labeled-text' | 'step-flow' | 'text-list';
+export type UiPluginSchemaType = 'text' | 'text-list' | 'step-list';
+export interface UiPluginTextSchema {
+    readonly type: 'text';
+    readonly maxLength: number;
+}
+export interface UiPluginTextListSchema {
+    readonly type: 'text-list';
+    readonly max: number;
+    readonly itemMaxLength: number;
+}
+export interface UiPluginStepListSchema {
+    readonly type: 'step-list';
+    readonly min: number;
+    readonly max: number;
+    readonly labelMaxLength: number;
+    readonly detailMaxLength: number;
+}
+export type UiPluginFieldSchema = UiPluginTextSchema | UiPluginTextListSchema | UiPluginStepListSchema;
+export type UiPluginSchema = Readonly<Record<string, UiPluginFieldSchema>>;
+export interface UiPluginActivation {
+    readonly kind: 'fenced-code';
+    readonly language: string;
+}
+export interface UiPluginCardShellNode {
+    readonly primitive: 'card-shell';
+}
+export interface UiPluginMetaBannerNode {
+    readonly primitive: 'meta-banner';
+    readonly badgeToken: string;
+    readonly noticeToken: string;
+}
+export interface UiPluginHeadingNode {
+    readonly primitive: 'heading';
+    readonly field: string;
+}
+export interface UiPluginLabeledTextNode {
+    readonly primitive: 'labeled-text';
+    readonly titleToken: string;
+    readonly field: string;
+    readonly variant: 'callout';
+}
+export interface UiPluginStepFlowNode {
+    readonly primitive: 'step-flow';
+    readonly titleToken: string;
+    readonly field: string;
+}
+export interface UiPluginTextListNode {
+    readonly primitive: 'text-list';
+    readonly titleToken: string;
+    readonly field: string;
+    readonly emptyToken?: string;
+    readonly hideWhenEmpty?: boolean;
+}
+export type UiPluginLayoutNode = UiPluginCardShellNode | UiPluginMetaBannerNode | UiPluginHeadingNode | UiPluginLabeledTextNode | UiPluginStepFlowNode | UiPluginTextListNode;
+export type UiPluginLayout = readonly UiPluginLayoutNode[];
+export interface UiPluginManifest {
+    readonly manifestVersion: 1;
+    readonly pluginId: string;
+    readonly definitionId: string;
+    readonly version: number;
+    readonly primitiveSet: number;
+    readonly activation: UiPluginActivation;
+    readonly schema: UiPluginSchema;
+    readonly layout: UiPluginLayout;
+}
+export interface UiPluginStep {
+    readonly label: string;
+    readonly detail: string;
+}
+export type UiPluginPayloadValue = string | string[] | UiPluginStep[];
+export type UiPluginPayload = Record<string, UiPluginPayloadValue>;
+export interface UiPluginValidationOptions {
+    readonly supportedPrimitiveSet?: number;
+}
+export type UiPluginValidationErrorCode = 'MANIFEST_INVALID' | 'PRIMITIVE_UNKNOWN' | 'PRIMITIVE_SET_UNSUPPORTED' | 'SCHEMA_TYPE_UNSUPPORTED' | 'TOKEN_INVALID' | 'UNSAFE_VALUE';

package/dist/ui-plugin/validator.d.ts

@@ -0,0 +1,9 @@
+import type { UiPluginManifest, UiPluginPayload, UiPluginValidationErrorCode, UiPluginValidationOptions } from './types.js';
+export declare class UiPluginValidationError extends Error {
+    readonly code: UiPluginValidationErrorCode;
+    readonly name = "UiPluginValidationError";
+    constructor(code: UiPluginValidationErrorCode, message?: string);
+}
+export declare function validateManifest(input: unknown, options?: UiPluginValidationOptions): UiPluginManifest;
+export declare function normalizeManifest(input: unknown, options?: UiPluginValidationOptions): UiPluginManifest;
+export declare function validatePayload(manifest: UiPluginManifest, rawPayload: unknown): UiPluginPayload;

package/dist/utils/crewx-home.d.ts

@@ -0,0 +1 @@
+export declare function getCrewxHome(): string;

package/dist/utils/id.d.ts

@@ -1,4 +1,4 @@
-export type EntityPrefix = 'tsk' | 'thd' | 'msg' | 'box' | 'prj' | 'mem' | 'spn' | 'cron' | 'wbs' | 'job' | 'tcl' | 'req' | 'ws' | 'wfr';
+export type EntityPrefix = 'tsk' | 'thd' | 'msg' | 'box' | 'prj' | 'mem' | 'spn' | 'cron' | 'wbs' | 'job' | 'tcl' | 'req' | 'ws' | 'wfr' | 'ntf' | 'sug' | 'brd' | 'pjc' | 'pje' | 'the' | 'thl' | 'thr';
 export type PrefixedId<P extends EntityPrefix> = `${P}_${string}`;
 export declare function generateId<P extends EntityPrefix>(prefix: P): PrefixedId<P>;
 export declare function generateFingerprint<P extends EntityPrefix>(prefix: P, input: string): PrefixedId<P>;

package/dist/utils/timestamp.d.ts

@@ -1 +1,2 @@
 export declare function formatTimestamp(date: Date): string;
+export declare function formatDisplayTimestamp(date: Date): string;

package/dist/wi/create.d.ts

@@ -0,0 +1,48 @@
+export type WiStatus = 'draft' | 'approved' | 'in-progress' | 'done' | 'cancelled';
+export interface WiCreateInput {
+    title: string;
+    assignee?: string;
+    body?: string;
+    board?: string;
+    source?: string;
+    depends_on?: string[];
+}
+export interface WiBatchCreateInput {
+    board: string;
+    source?: string;
+    items: Array<{
+        key?: string;
+        title: string;
+        assignee?: string;
+        depends_on?: string[];
+        body: string;
+    }>;
+}
+export interface WiCreatedSummary {
+    wi_id: string;
+    title: string;
+    status: WiStatus;
+    priority?: string;
+    assignee?: string;
+    depends_on: string[];
+    blocks: string[];
+    date?: string;
+    board?: string;
+    source: string;
+    screens: string[];
+    path: string;
+    mtime: number;
+}
+export interface WiCreatedDetail {
+    summary: WiCreatedSummary;
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface WiBatchCreateResult {
+    created: WiCreatedDetail[];
+}
+export declare class WiCreateError extends Error {
+    constructor(message: string);
+}
+export declare function createWorkInstruction(workspacePath: string, input: WiCreateInput): Promise<WiCreatedDetail>;
+export declare function createWorkInstructionBatch(workspacePath: string, input: WiBatchCreateInput): Promise<WiBatchCreateResult>;

package/dist/wi/select.d.ts

@@ -0,0 +1,20 @@
+export type WiSelectableStatus = 'draft' | 'approved' | 'in-progress' | 'done' | 'cancelled';
+export interface WiSummary {
+    wi_id: string;
+    status: WiSelectableStatus;
+    depends_on?: string[];
+}
+export type SelectNextWiResult = {
+    pick: string;
+} | {
+    blocked: true;
+    reason: string;
+} | {
+    cycle: string[];
+} | {
+    done: true;
+};
+export declare function selectNextWi(wis: WiSummary[], opts: {
+    batch: string[];
+    exclude?: string[];
+}): SelectNextWiResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/sdk",
-  "version": "0.9.0-rc.8",
+  "version": "0.9.0-rc.80",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"
@@ -50,6 +50,16 @@
       "import": "./dist/repository/index.js",
       "require": "./dist/repository/index.js"
     },
+    "./desktop": {
+      "types": "./dist/desktop/index.d.ts",
+      "import": "./dist/desktop/index.js",
+      "require": "./dist/desktop/index.js"
+    },
+    "./publish": {
+      "types": "./dist/publish/index.d.ts",
+      "import": "./dist/publish/index.js",
+      "require": "./dist/publish/index.js"
+    },
     "./package.json": "./package.json"
   },
   "browser": {
@@ -60,7 +70,11 @@
     "./dist/layout/loader.js": false,
     "./dist/esm/layout/loader.js": false,
     "./dist/repository/index.js": false,
-    "./dist/esm/repository/index.js": false
+    "./dist/esm/repository/index.js": false,
+    "./dist/desktop/index.js": false,
+    "./dist/esm/desktop/index.js": false,
+    "./dist/publish/index.js": false,
+    "./dist/esm/publish/index.js": false
   },
   "files": [
     "dist",
@@ -74,7 +88,9 @@
     "ai": "4.0.0",
     "drizzle-orm": "0.45.2",
     "handlebars": "4.7.9",
+    "js-tiktoken": "1.0.21",
     "js-yaml": "4.1.0",
+    "tar": "7.5.15",
     "zod": "3.25.76"
   },
   "peerDependencies": {