@agimon-ai/doompi-core 0.0.1-alpha.100

package/dist/src/schemas/contextContributions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextContributions.d.mts","names":[],"sources":["../../../src/schemas/contextContributions.ts"],"mappings":";;;qBAGa;iBAEI;WACN;WACA;WACA;WACA;;EAET;;iBAGe;WACN;WACA;WACA;WACA;WACA;;iBAGM;WACN;WACA;WACA;WACA;WACA;;iBAGM;WACN,kBAAkB;WAClB,iBAAiB;;iBAGX;;EAEf;;iBAGe;;WAEN;EACT,SAAS,cAAc,0BAA0B;EACjD,YAAY;;;YAIF;IACR,8BAA8B;;;wBAIlB,6BAA6B,SAAS,UAAU;wBAIhD,gCAAgC,SAAS,UAAU"}

package/dist/src/schemas/contextContributions.mjs

@@ -0,0 +1,15 @@
+//#region src/schemas/contextContributions.ts
+/** Session-scoped broker for bounded context rendered by optional Doom packages. */
+const DOOM_CONTEXT_CONTRIBUTIONS_SERVICE = "doom/context-contributions";
+function readDoomContextContributions(context) {
+	return context.get(DOOM_CONTEXT_CONTRIBUTIONS_SERVICE);
+}
+function requireDoomContextContributions(context) {
+	const service = readDoomContextContributions(context);
+	if (!service) throw new Error("Doom context contributions are unavailable. Start a Doom session first.");
+	return service;
+}
+//#endregion
+export { DOOM_CONTEXT_CONTRIBUTIONS_SERVICE, readDoomContextContributions, requireDoomContextContributions };
+
+//# sourceMappingURL=contextContributions.mjs.map

package/dist/src/schemas/contextContributions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextContributions.mjs","names":[],"sources":["../../../src/schemas/contextContributions.ts"],"sourcesContent":["import type { Context } from '@deepseek-ai/cordis';\n\n/** Session-scoped broker for bounded context rendered by optional Doom packages. */\nexport const DOOM_CONTEXT_CONTRIBUTIONS_SERVICE = 'doom/context-contributions';\n\nexport interface DoomContextContribution {\n  readonly source: string;\n  readonly id: string;\n  readonly label: string;\n  readonly order: number;\n  /** Returns provider-rendered, already-redacted text, or omits this contribution. */\n  snapshot(): string | undefined;\n}\n\nexport interface DoomContextContributionEntry {\n  readonly source: string;\n  readonly id: string;\n  readonly label: string;\n  readonly order: number;\n  readonly text: string;\n}\n\nexport interface DoomContextContributionError {\n  readonly source: string;\n  readonly id: string;\n  readonly label: string;\n  readonly order: number;\n  readonly message: string;\n}\n\nexport interface DoomContextContributionsSnapshot {\n  readonly entries: readonly DoomContextContributionEntry[];\n  readonly errors: readonly DoomContextContributionError[];\n}\n\nexport interface DoomContextContributionRegistration {\n  /** Removes the contribution. Repeated disposal is a no-op. */\n  dispose(): void;\n}\n\nexport interface DoomContextContributionsService {\n  /** Fences registrations and snapshots against a replaced Doom session. */\n  readonly generation: string;\n  register(contribution: DoomContextContribution): DoomContextContributionRegistration;\n  snapshot(): DoomContextContributionsSnapshot;\n}\n\ndeclare module '@deepseek-ai/cordis' {\n  interface Context {\n    'doom/context-contributions': DoomContextContributionsService;\n  }\n}\n\nexport function readDoomContextContributions(context: Context): DoomContextContributionsService | undefined {\n  return context.get(DOOM_CONTEXT_CONTRIBUTIONS_SERVICE) as DoomContextContributionsService | undefined;\n}\n\nexport function requireDoomContextContributions(context: Context): DoomContextContributionsService {\n  const service = readDoomContextContributions(context);\n  if (!service) throw new Error('Doom context contributions are unavailable. Start a Doom session first.');\n  return service;\n}\n"],"mappings":";;AAGA,MAAa,qCAAqC;AAkDlD,SAAgB,6BAA6B,SAA+D;CAC1G,OAAO,QAAQ,IAAI,kCAAkC;AACvD;AAEA,SAAgB,gCAAgC,SAAmD;CACjG,MAAM,UAAU,6BAA6B,OAAO;CACpD,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,yEAAyE;CACvG,OAAO;AACT"}

package/dist/src/schemas/delegation.cjs

@@ -0,0 +1,91 @@
+let typebox = require("typebox");
+//#region src/schemas/delegation.ts
+const InlineAgentSchema = typebox.Type.Object({ systemPrompt: typebox.Type.String({ minLength: 1 }) }, { additionalProperties: false });
+/** Shared Cordis contract for an optional delegated-run provider. */
+const DOOM_DELEGATION_SERVICE = "doom/delegation";
+const DOOM_DELEGATION_REQUESTED_EVENT = "doom/delegation/requested";
+const DOOM_DELEGATION_ACCEPTED_EVENT = "doom/delegation/accepted";
+const DOOM_DELEGATION_STARTED_EVENT = "doom/delegation/started";
+const DOOM_DELEGATION_UPDATED_EVENT = "doom/delegation/updated";
+const DOOM_DELEGATION_FINISHED_EVENT = "doom/delegation/finished";
+const DOOM_DELEGATION_CANCELLED_EVENT = "doom/delegation/cancelled";
+const DelegationRequestSchema = typebox.Type.Object({
+	requestId: typebox.Type.String({ minLength: 1 }),
+	taskId: typebox.Type.Union([typebox.Type.String(), typebox.Type.Number()]),
+	agent: typebox.Type.String({ minLength: 1 }),
+	inlineAgent: typebox.Type.Optional(InlineAgentSchema),
+	prompt: typebox.Type.String({ minLength: 1 }),
+	cwd: typebox.Type.String({ minLength: 1 }),
+	model: typebox.Type.Optional(typebox.Type.String({ minLength: 1 })),
+	context: typebox.Type.Optional(typebox.Type.Union([typebox.Type.Literal("fresh"), typebox.Type.Literal("fork")])),
+	timeoutMs: typebox.Type.Optional(typebox.Type.Integer({ minimum: 1 })),
+	artifacts: typebox.Type.Optional(typebox.Type.Boolean()),
+	runMode: typebox.Type.Optional(typebox.Type.Union([typebox.Type.Literal("foreground"), typebox.Type.Literal("detached")])),
+	teamTask: typebox.Type.Optional(typebox.Type.Object({
+		id: typebox.Type.String({ minLength: 1 }),
+		subject: typebox.Type.String({ minLength: 1 })
+	}, { additionalProperties: false }))
+}, { additionalProperties: false });
+const DelegationAcceptedSchema = typebox.Type.Object({ requestId: typebox.Type.String({ minLength: 1 }) }, { additionalProperties: false });
+const DelegationStartedSchema = typebox.Type.Object({
+	requestId: typebox.Type.String({ minLength: 1 }),
+	runId: typebox.Type.String({ minLength: 1 })
+}, { additionalProperties: false });
+const DelegationUpdateSchema = typebox.Type.Object({
+	requestId: typebox.Type.String({ minLength: 1 }),
+	runId: typebox.Type.String({ minLength: 1 }),
+	status: typebox.Type.Optional(typebox.Type.String({ minLength: 1 })),
+	currentTool: typebox.Type.Optional(typebox.Type.String({ minLength: 1 })),
+	toolCount: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 })),
+	durationMs: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 })),
+	tokens: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const DelegationStatusSchema = typebox.Type.Union([
+	typebox.Type.Literal("completed"),
+	typebox.Type.Literal("failed"),
+	typebox.Type.Literal("timed_out"),
+	typebox.Type.Literal("cancelled"),
+	typebox.Type.Literal("interrupted"),
+	typebox.Type.Literal("turn_budget_exhausted"),
+	typebox.Type.Literal("tool_budget_exhausted"),
+	typebox.Type.Literal("acceptance_failed"),
+	typebox.Type.Literal("invalid_request"),
+	typebox.Type.Literal("unavailable_context")
+]);
+const DelegationResultSchema = typebox.Type.Object({
+	requestId: typebox.Type.String({ minLength: 1 }),
+	runId: typebox.Type.String({ minLength: 1 }),
+	status: DelegationStatusSchema,
+	output: typebox.Type.Optional(typebox.Type.String()),
+	error: typebox.Type.Optional(typebox.Type.String()),
+	outputPath: typebox.Type.Optional(typebox.Type.String({ minLength: 1 })),
+	sessionFile: typebox.Type.Optional(typebox.Type.String({ minLength: 1 })),
+	durationMs: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 })),
+	toolCount: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const DelegationCancelSchema = typebox.Type.Object({
+	requestId: typebox.Type.String({ minLength: 1 }),
+	reason: typebox.Type.Optional(typebox.Type.String({ minLength: 1 }))
+}, { additionalProperties: false });
+function readDoomDelegationService(ctx) {
+	return ctx.get(DOOM_DELEGATION_SERVICE);
+}
+//#endregion
+exports.DOOM_DELEGATION_ACCEPTED_EVENT = DOOM_DELEGATION_ACCEPTED_EVENT;
+exports.DOOM_DELEGATION_CANCELLED_EVENT = DOOM_DELEGATION_CANCELLED_EVENT;
+exports.DOOM_DELEGATION_FINISHED_EVENT = DOOM_DELEGATION_FINISHED_EVENT;
+exports.DOOM_DELEGATION_REQUESTED_EVENT = DOOM_DELEGATION_REQUESTED_EVENT;
+exports.DOOM_DELEGATION_SERVICE = DOOM_DELEGATION_SERVICE;
+exports.DOOM_DELEGATION_STARTED_EVENT = DOOM_DELEGATION_STARTED_EVENT;
+exports.DOOM_DELEGATION_UPDATED_EVENT = DOOM_DELEGATION_UPDATED_EVENT;
+exports.DelegationAcceptedSchema = DelegationAcceptedSchema;
+exports.DelegationCancelSchema = DelegationCancelSchema;
+exports.DelegationRequestSchema = DelegationRequestSchema;
+exports.DelegationResultSchema = DelegationResultSchema;
+exports.DelegationStartedSchema = DelegationStartedSchema;
+exports.DelegationStatusSchema = DelegationStatusSchema;
+exports.DelegationUpdateSchema = DelegationUpdateSchema;
+exports.InlineAgentSchema = InlineAgentSchema;
+exports.readDoomDelegationService = readDoomDelegationService;
+
+//# sourceMappingURL=delegation.cjs.map

package/dist/src/schemas/delegation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.cjs","names":["Type"],"sources":["../../../src/schemas/delegation.ts"],"sourcesContent":["import type { Context } from '@deepseek-ai/cordis';\nimport { type Static, Type } from 'typebox';\n\nexport const InlineAgentSchema = Type.Object(\n  { systemPrompt: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\nexport type InlineAgent = Static<typeof InlineAgentSchema>;\n\n/** Shared Cordis contract for an optional delegated-run provider. */\nexport const DOOM_DELEGATION_SERVICE = 'doom/delegation';\nexport const DOOM_DELEGATION_REQUESTED_EVENT = 'doom/delegation/requested';\nexport const DOOM_DELEGATION_ACCEPTED_EVENT = 'doom/delegation/accepted';\nexport const DOOM_DELEGATION_STARTED_EVENT = 'doom/delegation/started';\nexport const DOOM_DELEGATION_UPDATED_EVENT = 'doom/delegation/updated';\nexport const DOOM_DELEGATION_FINISHED_EVENT = 'doom/delegation/finished';\nexport const DOOM_DELEGATION_CANCELLED_EVENT = 'doom/delegation/cancelled';\n\nexport const DelegationRequestSchema = Type.Object(\n  {\n    requestId: Type.String({ minLength: 1 }),\n    taskId: Type.Union([Type.String(), Type.Number()]),\n    agent: Type.String({ minLength: 1 }),\n    inlineAgent: Type.Optional(InlineAgentSchema),\n    prompt: Type.String({ minLength: 1 }),\n    cwd: Type.String({ minLength: 1 }),\n    model: Type.Optional(Type.String({ minLength: 1 })),\n    context: Type.Optional(Type.Union([Type.Literal('fresh'), Type.Literal('fork')])),\n    timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),\n    artifacts: Type.Optional(Type.Boolean()),\n    runMode: Type.Optional(Type.Union([Type.Literal('foreground'), Type.Literal('detached')])),\n    teamTask: Type.Optional(\n      Type.Object(\n        { id: Type.String({ minLength: 1 }), subject: Type.String({ minLength: 1 }) },\n        { additionalProperties: false },\n      ),\n    ),\n  },\n  { additionalProperties: false },\n);\nexport type DelegationRequest = Static<typeof DelegationRequestSchema>;\n\nexport const DelegationAcceptedSchema = Type.Object(\n  { requestId: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\nexport type DelegationAccepted = Static<typeof DelegationAcceptedSchema>;\n\nexport const DelegationStartedSchema = Type.Object(\n  { requestId: Type.String({ minLength: 1 }), runId: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\nexport type DelegationStarted = Static<typeof DelegationStartedSchema>;\n\nexport const DelegationUpdateSchema = Type.Object(\n  {\n    requestId: Type.String({ minLength: 1 }),\n    runId: Type.String({ minLength: 1 }),\n    status: Type.Optional(Type.String({ minLength: 1 })),\n    currentTool: Type.Optional(Type.String({ minLength: 1 })),\n    toolCount: Type.Optional(Type.Integer({ minimum: 0 })),\n    durationMs: Type.Optional(Type.Integer({ minimum: 0 })),\n    tokens: Type.Optional(Type.Integer({ minimum: 0 })),\n  },\n  { additionalProperties: false },\n);\nexport type DelegationUpdate = Static<typeof DelegationUpdateSchema>;\n\nexport const DelegationStatusSchema = Type.Union([\n  Type.Literal('completed'),\n  Type.Literal('failed'),\n  Type.Literal('timed_out'),\n  Type.Literal('cancelled'),\n  Type.Literal('interrupted'),\n  Type.Literal('turn_budget_exhausted'),\n  Type.Literal('tool_budget_exhausted'),\n  Type.Literal('acceptance_failed'),\n  Type.Literal('invalid_request'),\n  Type.Literal('unavailable_context'),\n]);\nexport type DelegationStatus = Static<typeof DelegationStatusSchema>;\n\nexport const DelegationResultSchema = Type.Object(\n  {\n    requestId: Type.String({ minLength: 1 }),\n    runId: Type.String({ minLength: 1 }),\n    status: DelegationStatusSchema,\n    output: Type.Optional(Type.String()),\n    error: Type.Optional(Type.String()),\n    outputPath: Type.Optional(Type.String({ minLength: 1 })),\n    sessionFile: Type.Optional(Type.String({ minLength: 1 })),\n    durationMs: Type.Optional(Type.Integer({ minimum: 0 })),\n    toolCount: Type.Optional(Type.Integer({ minimum: 0 })),\n  },\n  { additionalProperties: false },\n);\nexport type DelegationResult = Static<typeof DelegationResultSchema>;\n\nexport const DelegationCancelSchema = Type.Object(\n  { requestId: Type.String({ minLength: 1 }), reason: Type.Optional(Type.String({ minLength: 1 })) },\n  { additionalProperties: false },\n);\nexport type DelegationCancel = Static<typeof DelegationCancelSchema>;\n\nexport interface DoomDelegationService {\n  readonly sessionId: string;\n  readonly generation: string;\n  request(request: DelegationRequest): Promise<void>;\n  cancel(request: DelegationCancel): void;\n}\n\ndeclare module '@deepseek-ai/cordis' {\n  interface Context {\n    'doom/delegation': DoomDelegationService;\n  }\n\n  interface Events {\n    'doom/delegation/requested'(event: DelegationRequest): void;\n    'doom/delegation/accepted'(event: DelegationAccepted): void;\n    'doom/delegation/started'(event: DelegationStarted): void;\n    'doom/delegation/updated'(event: DelegationUpdate): void;\n    'doom/delegation/finished'(event: DelegationResult): void;\n    'doom/delegation/cancelled'(event: DelegationCancel): void;\n  }\n}\n\nexport function readDoomDelegationService(ctx: Context): DoomDelegationService | undefined {\n  return ctx.get(DOOM_DELEGATION_SERVICE) as DoomDelegationService | undefined;\n}\n"],"mappings":"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"}

package/dist/src/schemas/delegation.d.mts

@@ -0,0 +1,95 @@
+import { Static, Type } from "typebox";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/schemas/delegation.d.ts
+export declare const InlineAgentSchema: Type.TObject<{
+  systemPrompt: Type.TString;
+}>;
+export type InlineAgent = Static<typeof InlineAgentSchema>;
+/** Shared Cordis contract for an optional delegated-run provider. */
+export declare const DOOM_DELEGATION_SERVICE = "doom/delegation";
+export declare const DOOM_DELEGATION_REQUESTED_EVENT = "doom/delegation/requested";
+export declare const DOOM_DELEGATION_ACCEPTED_EVENT = "doom/delegation/accepted";
+export declare const DOOM_DELEGATION_STARTED_EVENT = "doom/delegation/started";
+export declare const DOOM_DELEGATION_UPDATED_EVENT = "doom/delegation/updated";
+export declare const DOOM_DELEGATION_FINISHED_EVENT = "doom/delegation/finished";
+export declare const DOOM_DELEGATION_CANCELLED_EVENT = "doom/delegation/cancelled";
+export declare const DelegationRequestSchema: Type.TObject<{
+  requestId: Type.TString;
+  taskId: Type.TUnion<[Type.TString, Type.TNumber]>;
+  agent: Type.TString;
+  inlineAgent: Type.TOptional<Type.TObject<{
+    systemPrompt: Type.TString;
+  }>>;
+  prompt: Type.TString;
+  cwd: Type.TString;
+  model: Type.TOptional<Type.TString>;
+  context: Type.TOptional<Type.TUnion<[Type.TLiteral<"fresh">, Type.TLiteral<"fork">]>>;
+  timeoutMs: Type.TOptional<Type.TInteger>;
+  artifacts: Type.TOptional<Type.TBoolean>;
+  runMode: Type.TOptional<Type.TUnion<[Type.TLiteral<"foreground">, Type.TLiteral<"detached">]>>;
+  teamTask: Type.TOptional<Type.TObject<{
+    id: Type.TString;
+    subject: Type.TString;
+  }>>;
+}>;
+export type DelegationRequest = Static<typeof DelegationRequestSchema>;
+export declare const DelegationAcceptedSchema: Type.TObject<{
+  requestId: Type.TString;
+}>;
+export type DelegationAccepted = Static<typeof DelegationAcceptedSchema>;
+export declare const DelegationStartedSchema: Type.TObject<{
+  requestId: Type.TString;
+  runId: Type.TString;
+}>;
+export type DelegationStarted = Static<typeof DelegationStartedSchema>;
+export declare const DelegationUpdateSchema: Type.TObject<{
+  requestId: Type.TString;
+  runId: Type.TString;
+  status: Type.TOptional<Type.TString>;
+  currentTool: Type.TOptional<Type.TString>;
+  toolCount: Type.TOptional<Type.TInteger>;
+  durationMs: Type.TOptional<Type.TInteger>;
+  tokens: Type.TOptional<Type.TInteger>;
+}>;
+export type DelegationUpdate = Static<typeof DelegationUpdateSchema>;
+export declare const DelegationStatusSchema: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"timed_out">, Type.TLiteral<"cancelled">, Type.TLiteral<"interrupted">, Type.TLiteral<"turn_budget_exhausted">, Type.TLiteral<"tool_budget_exhausted">, Type.TLiteral<"acceptance_failed">, Type.TLiteral<"invalid_request">, Type.TLiteral<"unavailable_context">]>;
+export type DelegationStatus = Static<typeof DelegationStatusSchema>;
+export declare const DelegationResultSchema: Type.TObject<{
+  requestId: Type.TString;
+  runId: Type.TString;
+  status: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"timed_out">, Type.TLiteral<"cancelled">, Type.TLiteral<"interrupted">, Type.TLiteral<"turn_budget_exhausted">, Type.TLiteral<"tool_budget_exhausted">, Type.TLiteral<"acceptance_failed">, Type.TLiteral<"invalid_request">, Type.TLiteral<"unavailable_context">]>;
+  output: Type.TOptional<Type.TString>;
+  error: Type.TOptional<Type.TString>;
+  outputPath: Type.TOptional<Type.TString>;
+  sessionFile: Type.TOptional<Type.TString>;
+  durationMs: Type.TOptional<Type.TInteger>;
+  toolCount: Type.TOptional<Type.TInteger>;
+}>;
+export type DelegationResult = Static<typeof DelegationResultSchema>;
+export declare const DelegationCancelSchema: Type.TObject<{
+  requestId: Type.TString;
+  reason: Type.TOptional<Type.TString>;
+}>;
+export type DelegationCancel = Static<typeof DelegationCancelSchema>;
+export interface DoomDelegationService {
+  readonly sessionId: string;
+  readonly generation: string;
+  request(request: DelegationRequest): Promise<void>;
+  cancel(request: DelegationCancel): void;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    'doom/delegation': DoomDelegationService;
+  }
+  interface Events {
+    'doom/delegation/requested'(event: DelegationRequest): void;
+    'doom/delegation/accepted'(event: DelegationAccepted): void;
+    'doom/delegation/started'(event: DelegationStarted): void;
+    'doom/delegation/updated'(event: DelegationUpdate): void;
+    'doom/delegation/finished'(event: DelegationResult): void;
+    'doom/delegation/cancelled'(event: DelegationCancel): void;
+  }
+}
+export declare function readDoomDelegationService(ctx: Context): DoomDelegationService | undefined;
+//#endregion
+//# sourceMappingURL=delegation.d.mts.map

package/dist/src/schemas/delegation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.d.mts","names":[],"sources":["../../../src/schemas/delegation.ts"],"mappings":";;;qBAGa,mBAAiB,KAAA;;;YAIlB,cAAc,cAAc;;qBAG3B;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBAEA,yBAAuB,KAAA;;;;;;;;;;;;;;;;;;;YAsBxB,oBAAoB,cAAc;qBAEjC,0BAAwB,KAAA;;;YAIzB,qBAAqB,cAAc;qBAElC,yBAAuB,KAAA;;;;YAIxB,oBAAoB,cAAc;qBAEjC,wBAAsB,KAAA;;;;;;;;;YAYvB,mBAAmB,cAAc;qBAEhC,wBAAsB,KAAA,QAAA,KAAA,uBAAA,KAAA,oBAAA,KAAA,uBAAA,KAAA,uBAAA,KAAA,yBAAA,KAAA,mCAAA,KAAA,mCAAA,KAAA,+BAAA,KAAA,6BAAA,KAAA;YAYvB,mBAAmB,cAAc;qBAEhC,wBAAsB,KAAA;;;;;;;;;;;YAcvB,mBAAmB,cAAc;qBAEhC,wBAAsB,KAAA;;;;YAIvB,mBAAmB,cAAc;iBAE5B;WACN;WACA;EACT,QAAQ,SAAS,oBAAoB;EACrC,OAAO,SAAS;;;YAIN;IACR,mBAAmB;;YAGX;IACR,4BAA4B,OAAO;IACnC,2BAA2B,OAAO;IAClC,0BAA0B,OAAO;IACjC,0BAA0B,OAAO;IACjC,2BAA2B,OAAO;IAClC,4BAA4B,OAAO;;;wBAIvB,0BAA0B,KAAK,UAAU"}

package/dist/src/schemas/delegation.mjs

@@ -0,0 +1,76 @@
+import { Type } from "typebox";
+//#region src/schemas/delegation.ts
+const InlineAgentSchema = Type.Object({ systemPrompt: Type.String({ minLength: 1 }) }, { additionalProperties: false });
+/** Shared Cordis contract for an optional delegated-run provider. */
+const DOOM_DELEGATION_SERVICE = "doom/delegation";
+const DOOM_DELEGATION_REQUESTED_EVENT = "doom/delegation/requested";
+const DOOM_DELEGATION_ACCEPTED_EVENT = "doom/delegation/accepted";
+const DOOM_DELEGATION_STARTED_EVENT = "doom/delegation/started";
+const DOOM_DELEGATION_UPDATED_EVENT = "doom/delegation/updated";
+const DOOM_DELEGATION_FINISHED_EVENT = "doom/delegation/finished";
+const DOOM_DELEGATION_CANCELLED_EVENT = "doom/delegation/cancelled";
+const DelegationRequestSchema = Type.Object({
+	requestId: Type.String({ minLength: 1 }),
+	taskId: Type.Union([Type.String(), Type.Number()]),
+	agent: Type.String({ minLength: 1 }),
+	inlineAgent: Type.Optional(InlineAgentSchema),
+	prompt: Type.String({ minLength: 1 }),
+	cwd: Type.String({ minLength: 1 }),
+	model: Type.Optional(Type.String({ minLength: 1 })),
+	context: Type.Optional(Type.Union([Type.Literal("fresh"), Type.Literal("fork")])),
+	timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
+	artifacts: Type.Optional(Type.Boolean()),
+	runMode: Type.Optional(Type.Union([Type.Literal("foreground"), Type.Literal("detached")])),
+	teamTask: Type.Optional(Type.Object({
+		id: Type.String({ minLength: 1 }),
+		subject: Type.String({ minLength: 1 })
+	}, { additionalProperties: false }))
+}, { additionalProperties: false });
+const DelegationAcceptedSchema = Type.Object({ requestId: Type.String({ minLength: 1 }) }, { additionalProperties: false });
+const DelegationStartedSchema = Type.Object({
+	requestId: Type.String({ minLength: 1 }),
+	runId: Type.String({ minLength: 1 })
+}, { additionalProperties: false });
+const DelegationUpdateSchema = Type.Object({
+	requestId: Type.String({ minLength: 1 }),
+	runId: Type.String({ minLength: 1 }),
+	status: Type.Optional(Type.String({ minLength: 1 })),
+	currentTool: Type.Optional(Type.String({ minLength: 1 })),
+	toolCount: Type.Optional(Type.Integer({ minimum: 0 })),
+	durationMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	tokens: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const DelegationStatusSchema = Type.Union([
+	Type.Literal("completed"),
+	Type.Literal("failed"),
+	Type.Literal("timed_out"),
+	Type.Literal("cancelled"),
+	Type.Literal("interrupted"),
+	Type.Literal("turn_budget_exhausted"),
+	Type.Literal("tool_budget_exhausted"),
+	Type.Literal("acceptance_failed"),
+	Type.Literal("invalid_request"),
+	Type.Literal("unavailable_context")
+]);
+const DelegationResultSchema = Type.Object({
+	requestId: Type.String({ minLength: 1 }),
+	runId: Type.String({ minLength: 1 }),
+	status: DelegationStatusSchema,
+	output: Type.Optional(Type.String()),
+	error: Type.Optional(Type.String()),
+	outputPath: Type.Optional(Type.String({ minLength: 1 })),
+	sessionFile: Type.Optional(Type.String({ minLength: 1 })),
+	durationMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	toolCount: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const DelegationCancelSchema = Type.Object({
+	requestId: Type.String({ minLength: 1 }),
+	reason: Type.Optional(Type.String({ minLength: 1 }))
+}, { additionalProperties: false });
+function readDoomDelegationService(ctx) {
+	return ctx.get(DOOM_DELEGATION_SERVICE);
+}
+//#endregion
+export { DOOM_DELEGATION_ACCEPTED_EVENT, DOOM_DELEGATION_CANCELLED_EVENT, DOOM_DELEGATION_FINISHED_EVENT, DOOM_DELEGATION_REQUESTED_EVENT, DOOM_DELEGATION_SERVICE, DOOM_DELEGATION_STARTED_EVENT, DOOM_DELEGATION_UPDATED_EVENT, DelegationAcceptedSchema, DelegationCancelSchema, DelegationRequestSchema, DelegationResultSchema, DelegationStartedSchema, DelegationStatusSchema, DelegationUpdateSchema, InlineAgentSchema, readDoomDelegationService };
+
+//# sourceMappingURL=delegation.mjs.map

package/dist/src/schemas/delegation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.mjs","names":[],"sources":["../../../src/schemas/delegation.ts"],"sourcesContent":["import type { Context } from '@deepseek-ai/cordis';\nimport { type Static, Type } from 'typebox';\n\nexport const InlineAgentSchema = Type.Object(\n  { systemPrompt: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\nexport type InlineAgent = Static<typeof InlineAgentSchema>;\n\n/** Shared Cordis contract for an optional delegated-run provider. */\nexport const DOOM_DELEGATION_SERVICE = 'doom/delegation';\nexport const DOOM_DELEGATION_REQUESTED_EVENT = 'doom/delegation/requested';\nexport const DOOM_DELEGATION_ACCEPTED_EVENT = 'doom/delegation/accepted';\nexport const DOOM_DELEGATION_STARTED_EVENT = 'doom/delegation/started';\nexport const DOOM_DELEGATION_UPDATED_EVENT = 'doom/delegation/updated';\nexport const DOOM_DELEGATION_FINISHED_EVENT = 'doom/delegation/finished';\nexport const DOOM_DELEGATION_CANCELLED_EVENT = 'doom/delegation/cancelled';\n\nexport const DelegationRequestSchema = Type.Object(\n  {\n    requestId: Type.String({ minLength: 1 }),\n    taskId: Type.Union([Type.String(), Type.Number()]),\n    agent: Type.String({ minLength: 1 }),\n    inlineAgent: Type.Optional(InlineAgentSchema),\n    prompt: Type.String({ minLength: 1 }),\n    cwd: Type.String({ minLength: 1 }),\n    model: Type.Optional(Type.String({ minLength: 1 })),\n    context: Type.Optional(Type.Union([Type.Literal('fresh'), Type.Literal('fork')])),\n    timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),\n    artifacts: Type.Optional(Type.Boolean()),\n    runMode: Type.Optional(Type.Union([Type.Literal('foreground'), Type.Literal('detached')])),\n    teamTask: Type.Optional(\n      Type.Object(\n        { id: Type.String({ minLength: 1 }), subject: Type.String({ minLength: 1 }) },\n        { additionalProperties: false },\n      ),\n    ),\n  },\n  { additionalProperties: false },\n);\nexport type DelegationRequest = Static<typeof DelegationRequestSchema>;\n\nexport const DelegationAcceptedSchema = Type.Object(\n  { requestId: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\nexport type DelegationAccepted = Static<typeof DelegationAcceptedSchema>;\n\nexport const DelegationStartedSchema = Type.Object(\n  { requestId: Type.String({ minLength: 1 }), runId: Type.String({ minLength: 1 }) },\n  { additionalProperties: false },\n);\nexport type DelegationStarted = Static<typeof DelegationStartedSchema>;\n\nexport const DelegationUpdateSchema = Type.Object(\n  {\n    requestId: Type.String({ minLength: 1 }),\n    runId: Type.String({ minLength: 1 }),\n    status: Type.Optional(Type.String({ minLength: 1 })),\n    currentTool: Type.Optional(Type.String({ minLength: 1 })),\n    toolCount: Type.Optional(Type.Integer({ minimum: 0 })),\n    durationMs: Type.Optional(Type.Integer({ minimum: 0 })),\n    tokens: Type.Optional(Type.Integer({ minimum: 0 })),\n  },\n  { additionalProperties: false },\n);\nexport type DelegationUpdate = Static<typeof DelegationUpdateSchema>;\n\nexport const DelegationStatusSchema = Type.Union([\n  Type.Literal('completed'),\n  Type.Literal('failed'),\n  Type.Literal('timed_out'),\n  Type.Literal('cancelled'),\n  Type.Literal('interrupted'),\n  Type.Literal('turn_budget_exhausted'),\n  Type.Literal('tool_budget_exhausted'),\n  Type.Literal('acceptance_failed'),\n  Type.Literal('invalid_request'),\n  Type.Literal('unavailable_context'),\n]);\nexport type DelegationStatus = Static<typeof DelegationStatusSchema>;\n\nexport const DelegationResultSchema = Type.Object(\n  {\n    requestId: Type.String({ minLength: 1 }),\n    runId: Type.String({ minLength: 1 }),\n    status: DelegationStatusSchema,\n    output: Type.Optional(Type.String()),\n    error: Type.Optional(Type.String()),\n    outputPath: Type.Optional(Type.String({ minLength: 1 })),\n    sessionFile: Type.Optional(Type.String({ minLength: 1 })),\n    durationMs: Type.Optional(Type.Integer({ minimum: 0 })),\n    toolCount: Type.Optional(Type.Integer({ minimum: 0 })),\n  },\n  { additionalProperties: false },\n);\nexport type DelegationResult = Static<typeof DelegationResultSchema>;\n\nexport const DelegationCancelSchema = Type.Object(\n  { requestId: Type.String({ minLength: 1 }), reason: Type.Optional(Type.String({ minLength: 1 })) },\n  { additionalProperties: false },\n);\nexport type DelegationCancel = Static<typeof DelegationCancelSchema>;\n\nexport interface DoomDelegationService {\n  readonly sessionId: string;\n  readonly generation: string;\n  request(request: DelegationRequest): Promise<void>;\n  cancel(request: DelegationCancel): void;\n}\n\ndeclare module '@deepseek-ai/cordis' {\n  interface Context {\n    'doom/delegation': DoomDelegationService;\n  }\n\n  interface Events {\n    'doom/delegation/requested'(event: DelegationRequest): void;\n    'doom/delegation/accepted'(event: DelegationAccepted): void;\n    'doom/delegation/started'(event: DelegationStarted): void;\n    'doom/delegation/updated'(event: DelegationUpdate): void;\n    'doom/delegation/finished'(event: DelegationResult): void;\n    'doom/delegation/cancelled'(event: DelegationCancel): void;\n  }\n}\n\nexport function readDoomDelegationService(ctx: Context): DoomDelegationService | undefined {\n  return ctx.get(DOOM_DELEGATION_SERVICE) as DoomDelegationService | undefined;\n}\n"],"mappings":"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"}

package/dist/src/schemas/extensionFile.d.mts

@@ -0,0 +1,136 @@
+import { PiToolDeclaration } from "./piTool.mjs";
+import { DoomPluginCommand, DoomPluginTool } from "./pluginContributions.mjs";
+import { PluginLifecycleHooks } from "../services/pluginLifecycle/index.mjs";
+import { PiEventHandlers } from "../../runtimePiExtension.mjs";
+import { DoomHubChannel } from "./hubChannel.mjs";
+import { DoomApi } from "./packageApi.mjs";
+import { DoomHeadlessActivity, DoomHeadlessCommand, DoomHeadlessEventName, DoomHeadlessHook, DoomHeadlessTool } from "./headless.mjs";
+import { DoomServerMethod } from "./serverFacet.mjs";
+import { TSchema } from "typebox";
+import { Context } from "@deepseek-ai/cordis";
+import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+//#region src/schemas/extensionFile.d.ts
+/**
+ * What a folder-routed file may export, per surface.
+ *
+ * A routed file declares one contribution and the path supplies its identity,
+ * so these types are the host contract with the path-derived keys made
+ * optional rather than removed. Optional is deliberate: the generator spreads
+ * the authored value over the derived identity, so a file that states its own
+ * name keeps it. Removing the key would make that legal-at-runtime case a type
+ * error.
+ *
+ * Every routed surface also accepts a factory, because a contribution that
+ * needs the mount context cannot be built at module scope.
+ *
+ * See docs/extension-layout.md for which folder produces which of these.
+ */
+/** The host contract with the keys a path derives made optional. */
+export type PathSupplied<TContribution, TKeys extends keyof TContribution> = TContribution extends unknown ? Omit<TContribution, TKeys> & Partial<Pick<TContribution, TKeys>> : never;
+export type RoutedCardinality = 'optional' | 'many' | 'collection';
+export interface RoutedFileOptions {
+  readonly cardinality: RoutedCardinality;
+}
+/** A declaration, or a factory the generator calls with the mount context. */
+export type OrFactory<TDeclaration, TContext> = TDeclaration | ((context: TContext) => TDeclaration);
+/**
+ * `tool/<name>.ts`. The filename becomes the tool name in snake case.
+ *
+ * `kind` is absent because the helper adds it, which is also what keeps this
+ * distinct from the neutral `defineTool` a hand-written entry uses.
+ */
+export type ToolFile<TContext = unknown> = OrFactory<PathSupplied<Omit<DoomPluginTool, 'kind'>, 'name'>, TContext>;
+/** What `defineTool` returns: the authored shape with the discriminant restored. */
+export type ToolContribution<TContext = unknown> = OrFactory<PathSupplied<DoomPluginTool, 'name'>, TContext>;
+/**
+ * `tool/<name>.server.ts`. A tool the headless host registers directly.
+ *
+ * Distinct from `ToolFile` on purpose. A portable tool carries `kind` and goes
+ * through the host's adapter, which composes abort signals and turns a throw
+ * into an error result. A native one is handed to the host untouched. Choosing
+ * between them is a real decision, so it is spelled by the helper rather than
+ * inferred from the shape.
+ */
+export type ServerToolFile<TParameters extends TSchema = TSchema, TContext = unknown> = OrFactory<PathSupplied<DoomHeadlessTool<TParameters>, 'name'>, TContext>;
+/**
+ * What a scope's `root.ts` returns: the value its subtree shares, its
+ * injectable services, session startup work, and lifetime hooks.
+ *
+ * `value` joins the mount context of every contribution beneath it, under
+ * `root`. Services register before deferred contributions are built, and
+ * `onStart` runs after the host registers them. That is when startup work may
+ * call back into a contribution.
+ */
+export interface RootDeclaration<TValue, TContext = unknown> extends PluginLifecycleHooks<TContext> {
+  readonly value: TValue;
+  readonly services?: readonly Parameters<Context['plugin']>[0][];
+  readonly activities?: readonly DoomHeadlessActivity[];
+}
+/**
+ * `root.ts`. One per scope and side, as Next.js spells a layout.
+ *
+ * Always a factory: a scope is constructed from its mount, and building the
+ * graph at module scope is the module-level singleton the Cordis ownership
+ * rules exist to prevent.
+ */
+export type RootFile<TValue, TContext = unknown> = (context: TContext) => RootDeclaration<TValue, TContext> | Promise<RootDeclaration<TValue, TContext>>;
+/** A mount context with the nearest root's value attached, as a routed file sees it. */
+export type WithRoot<TContext, TValue> = TContext & {
+  readonly root: TValue;
+};
+/**
+ * `tool/<name>.cli.ts`. A native interactive tool, handed to Pi untouched.
+ *
+ * The interactive counterpart of `ServerToolFile`. Pi's execute signature and
+ * its registry are its own, so a tool that needs them is declared with
+ * `definePiTool` rather than the portable shape; this is the factory form of
+ * that, for a tool built from the mount rather than at module scope.
+ */
+export type CliToolFile<TContext = unknown> = OrFactory<PiToolDeclaration | DoomPluginTool | Parameters<ExtensionAPI['registerTool']>[0], TContext>;
+/** `command/<name>.ts`. The filename becomes the command name in kebab case. */
+export type CommandFile<TContext = unknown> = OrFactory<PathSupplied<Omit<DoomPluginCommand, 'kind'>, 'name'>, TContext>;
+/** What `defineCommand` returns: the authored shape with the discriminant restored. */
+export type CommandContribution<TContext = unknown> = OrFactory<PathSupplied<DoomPluginCommand, 'name'>, TContext>;
+/** `command/<name>.cli.ts`. A native Pi command or portable Doom command. */
+export type CliCommandFile<TContext = unknown> = OrFactory<DoomPluginCommand | readonly [...Parameters<ExtensionAPI['registerCommand']>], TContext>;
+/** `command/<name>.server.ts`. A command registered by the headless session host. */
+export type ServerCommandFile<TContext = unknown> = OrFactory<PathSupplied<DoomHeadlessCommand | DoomPluginCommand, 'name'>, TContext>;
+/** One native Pi event handler from the host's overloaded event map. */
+export type CliHookHandler = PiEventHandlers[keyof PiEventHandlers];
+/** `hook/<event>.cli.ts`. A factory for one native Pi event handler. */
+export type CliHookFile<TContext, THandler extends CliHookHandler> = (context: TContext) => THandler;
+/** `overlay/<name>.cli.ts`. A terminal view opened directly by a command. */
+export type OverlayFile = (...args: never[]) => unknown;
+/**
+ * `hook/<event>.ts`. The filename becomes the event in snake case.
+ *
+ * Naming the event in the file as well is worth it when the handler needs a
+ * precise payload: the event is the discriminant, so leaving it to the path
+ * widens the handler's argument to every event's union.
+ */
+export type HookFile<TEvent extends DoomHeadlessEventName = DoomHeadlessEventName, TContext = unknown> = OrFactory<PathSupplied<DoomHeadlessHook<TEvent>, 'event'>, TContext>;
+/**
+ * A scope root service factory returning a Cordis plugin.
+ *
+ * Always a factory, never the plugin bare. A Cordis plugin is itself a
+ * function, so no runtime test separates one from a `(context) => plugin`
+ * factory; making the surface uniformly a factory removes the ambiguity
+ * instead of guessing at it.
+ *
+ * It matters because this is how a package with shared per-mount state
+ * decomposes. The factory receives the mount context, builds the graph the
+ * package's tools, commands and hooks all read, and publishes it on the
+ * Cordis context. Every other surface is emitted as a getter, so it is built
+ * after the service fibers are up and can inject what this published.
+ */
+export type ServiceFile<TContext = unknown> = (context: TContext) => Parameters<Context['plugin']>[0];
+/** `channel/<frameType>.ts`. The array holds factories, so this is one. */
+export type ChannelFile = () => PathSupplied<DoomHubChannel, 'frameType'>;
+/** `api/<segments>/route.ts`. The folder path is the route; nothing is derived into the value. */
+export type RouteFile<TContext = unknown> = OrFactory<DoomApi, TContext>;
+/** `method/<member>.ts`. Build it with `defineServerMethod` to keep schema inference. */
+export type MethodFile<TContext = unknown> = OrFactory<DoomServerMethod, TContext>;
+/** A session root activity. Activities name themselves. */
+export type ActivityFile<TContext = unknown> = OrFactory<DoomHeadlessActivity, TContext>;
+//#endregion
+//# sourceMappingURL=extensionFile.d.mts.map

package/dist/src/schemas/extensionFile.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionFile.d.mts","names":[],"sources":["../../../src/schemas/extensionFile.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoCY,aAAa,eAAe,oBAAoB,iBAAiB,gCACzE,KAAK,eAAe,SAAS,QAAQ,KAAK,eAAe;YAGjD;iBACK;WACN,aAAa;;;YAIZ,UAAU,cAAc,YAAY,iBAAiB,SAAS,aAAa;;;;;;;YAQ3E,SAAS,sBAAsB,UAAU,aAAa,KAAK,kCAAkC;;YAG7F,iBAAiB,sBAAsB,UAAU,aAAa,yBAAyB;;;;;;;;;;YAWvF,eAAe,oBAAoB,UAAU,SAAS,sBAAsB,UACtF,aAAa,iBAAiB,uBAC9B;;;;;;;;;;iBAYe,gBAAgB,QAAQ,4BAA4B,qBAAqB;WAC/E,OAAO;WACP,oBAAoB,WAAW;WAC/B,sBAAsB;;;;;;;;;YAUrB,SAAS,QAAQ,uBAC3B,SAAS,aACN,gBAAgB,QAAQ,YAAY,QAAQ,gBAAgB,QAAQ;;YAG7D,SAAS,UAAU,UAAU;WAAsB,MAAM;;;;;;;;;;YAUzD,YAAY,sBAAsB,UAC5C,oBAAoB,iBAAiB,WAAW,kCAChD;;YAIU,YAAY,sBAAsB,UAC5C,aAAa,KAAK,qCAClB;;YAIU,oBAAoB,sBAAsB,UAAU,aAAa,4BAA4B;;YAG7F,eAAe,sBAAsB,UAC/C,iCAAiC,WAAW,mCAC5C;;YAIU,kBAAkB,sBAAsB,UAClD,aAAa,sBAAsB,4BACnC;;YAIU,iBAAiB,sBAAsB;;YAGvC,YAAY,UAAU,iBAAiB,mBAAmB,SAAS,aAAa;;YAGhF,kBAAkB;;;;;;;;YASlB,SAAS,eAAe,wBAAwB,uBAAuB,sBAAsB,UACvG,aAAa,iBAAiB,mBAC9B;;;;;;;;;;;;;;;YAiBU,YAAY,uBAAuB,SAAS,aAAa,WAAW;;YAGpE,oBAAoB,aAAa;;YAGjC,UAAU,sBAAsB,UAAU,SAAS;;YAGnD,WAAW,sBAAsB,UAAU,kBAAkB;;YAG7D,aAAa,sBAAsB,UAAU,sBAAsB"}

package/dist/src/schemas/footer.cjs

@@ -0,0 +1,48 @@
+let typebox = require("typebox");
+//#region src/schemas/footer.ts
+const FooterTextColorSchema = typebox.Type.Union([
+	typebox.Type.Literal("accent"),
+	typebox.Type.Literal("mdCode"),
+	typebox.Type.Literal("toolDiffAdded"),
+	typebox.Type.Literal("warning"),
+	typebox.Type.Literal("mdHeading"),
+	typebox.Type.Literal("syntaxNumber"),
+	typebox.Type.Literal("muted"),
+	typebox.Type.Literal("dim")
+]);
+const FooterStatusPlacementSchema = typebox.Type.Union([typebox.Type.Literal("modeline"), typebox.Type.Literal("beforeModel")]);
+const FooterTextSegmentSchema = typebox.Type.Object({
+	text: typebox.Type.String({
+		minLength: 1,
+		maxLength: 80
+	}),
+	color: typebox.Type.Optional(FooterTextColorSchema)
+}, { additionalProperties: false });
+const FooterStatusItemSchema = typebox.Type.Object({
+	id: typebox.Type.String({
+		minLength: 1,
+		maxLength: 128
+	}),
+	fullText: typebox.Type.String({
+		minLength: 1,
+		maxLength: 80
+	}),
+	compactText: typebox.Type.String({
+		minLength: 1,
+		maxLength: 24
+	}),
+	fullSegments: typebox.Type.Optional(typebox.Type.Array(FooterTextSegmentSchema, { maxItems: 80 })),
+	compactSegments: typebox.Type.Optional(typebox.Type.Array(FooterTextSegmentSchema, { maxItems: 24 })),
+	placement: typebox.Type.Optional(FooterStatusPlacementSchema),
+	order: typebox.Type.Integer({
+		minimum: 0,
+		maximum: 1e3
+	})
+}, { additionalProperties: false });
+//#endregion
+exports.FooterStatusItemSchema = FooterStatusItemSchema;
+exports.FooterStatusPlacementSchema = FooterStatusPlacementSchema;
+exports.FooterTextColorSchema = FooterTextColorSchema;
+exports.FooterTextSegmentSchema = FooterTextSegmentSchema;
+
+//# sourceMappingURL=footer.cjs.map

package/dist/src/schemas/footer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.cjs","names":["Type"],"sources":["../../../src/schemas/footer.ts"],"sourcesContent":["import { type Static, Type } from 'typebox';\n\nexport const FooterTextColorSchema = Type.Union([\n  Type.Literal('accent'),\n  Type.Literal('mdCode'),\n  Type.Literal('toolDiffAdded'),\n  Type.Literal('warning'),\n  Type.Literal('mdHeading'),\n  Type.Literal('syntaxNumber'),\n  Type.Literal('muted'),\n  Type.Literal('dim'),\n]);\nexport type FooterTextColor = Static<typeof FooterTextColorSchema>;\n\nexport const FooterStatusPlacementSchema = Type.Union([Type.Literal('modeline'), Type.Literal('beforeModel')]);\nexport type FooterStatusPlacement = Static<typeof FooterStatusPlacementSchema>;\n\nexport const FooterTextSegmentSchema = Type.Object(\n  {\n    text: Type.String({ minLength: 1, maxLength: 80 }),\n    color: Type.Optional(FooterTextColorSchema),\n  },\n  { additionalProperties: false },\n);\nexport type FooterTextSegment = Static<typeof FooterTextSegmentSchema>;\n\nexport const FooterStatusItemSchema = Type.Object(\n  {\n    id: Type.String({ minLength: 1, maxLength: 128 }),\n    fullText: Type.String({ minLength: 1, maxLength: 80 }),\n    compactText: Type.String({ minLength: 1, maxLength: 24 }),\n    fullSegments: Type.Optional(Type.Array(FooterTextSegmentSchema, { maxItems: 80 })),\n    compactSegments: Type.Optional(Type.Array(FooterTextSegmentSchema, { maxItems: 24 })),\n    placement: Type.Optional(FooterStatusPlacementSchema),\n    order: Type.Integer({ minimum: 0, maximum: 1000 }),\n  },\n  { additionalProperties: false },\n);\nexport type FooterStatusItem = Static<typeof FooterStatusItemSchema>;\n\nexport interface DoomFooterContributionDefinition {\n  source: string;\n  id: string;\n  order: number;\n  placement?: FooterStatusPlacement;\n}\n\nexport interface DoomFooterContributionValue {\n  fullText: string;\n  compactText: string;\n  fullSegments?: FooterTextSegment[];\n  compactSegments?: FooterTextSegment[];\n}\n\nexport interface DoomFooterContributionHandle {\n  update(value: DoomFooterContributionValue | undefined): void;\n  dispose(): void;\n}\n\nexport interface DoomFooterStatus extends FooterStatusItem {\n  source: string;\n}\n"],"mappings":";;AAEA,MAAa,wBAAwBA,QAAAA,KAAK,MAAM;CAC9CA,QAAAA,KAAK,QAAQ,QAAQ;CACrBA,QAAAA,KAAK,QAAQ,QAAQ;CACrBA,QAAAA,KAAK,QAAQ,eAAe;CAC5BA,QAAAA,KAAK,QAAQ,SAAS;CACtBA,QAAAA,KAAK,QAAQ,WAAW;CACxBA,QAAAA,KAAK,QAAQ,cAAc;CAC3BA,QAAAA,KAAK,QAAQ,OAAO;CACpBA,QAAAA,KAAK,QAAQ,KAAK;AACpB,CAAC;AAGD,MAAa,8BAA8BA,QAAAA,KAAK,MAAM,CAACA,QAAAA,KAAK,QAAQ,UAAU,GAAGA,QAAAA,KAAK,QAAQ,aAAa,CAAC,CAAC;AAG7G,MAAa,0BAA0BA,QAAAA,KAAK,OAC1C;CACE,MAAMA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAG,CAAC;CACjD,OAAOA,QAAAA,KAAK,SAAS,qBAAqB;AAC5C,GACA,EAAE,sBAAsB,MAAM,CAChC;AAGA,MAAa,yBAAyBA,QAAAA,KAAK,OACzC;CACE,IAAIA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAI,CAAC;CAChD,UAAUA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAG,CAAC;CACrD,aAAaA,QAAAA,KAAK,OAAO;EAAE,WAAW;EAAG,WAAW;CAAG,CAAC;CACxD,cAAcA,QAAAA,KAAK,SAASA,QAAAA,KAAK,MAAM,yBAAyB,EAAE,UAAU,GAAG,CAAC,CAAC;CACjF,iBAAiBA,QAAAA,KAAK,SAASA,QAAAA,KAAK,MAAM,yBAAyB,EAAE,UAAU,GAAG,CAAC,CAAC;CACpF,WAAWA,QAAAA,KAAK,SAAS,2BAA2B;CACpD,OAAOA,QAAAA,KAAK,QAAQ;EAAE,SAAS;EAAG,SAAS;CAAK,CAAC;AACnD,GACA,EAAE,sBAAsB,MAAM,CAChC"}

package/dist/src/schemas/footer.d.mts

@@ -0,0 +1,48 @@
+import { Static, Type } from "typebox";
+//#region src/schemas/footer.d.ts
+export declare const FooterTextColorSchema: Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"mdCode">, Type.TLiteral<"toolDiffAdded">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"syntaxNumber">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>;
+export type FooterTextColor = Static<typeof FooterTextColorSchema>;
+export declare const FooterStatusPlacementSchema: Type.TUnion<[Type.TLiteral<"modeline">, Type.TLiteral<"beforeModel">]>;
+export type FooterStatusPlacement = Static<typeof FooterStatusPlacementSchema>;
+export declare const FooterTextSegmentSchema: Type.TObject<{
+  text: Type.TString;
+  color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"mdCode">, Type.TLiteral<"toolDiffAdded">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"syntaxNumber">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+}>;
+export type FooterTextSegment = Static<typeof FooterTextSegmentSchema>;
+export declare const FooterStatusItemSchema: Type.TObject<{
+  id: Type.TString;
+  fullText: Type.TString;
+  compactText: Type.TString;
+  fullSegments: Type.TOptional<Type.TArray<Type.TObject<{
+    text: Type.TString;
+    color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"mdCode">, Type.TLiteral<"toolDiffAdded">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"syntaxNumber">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+  }>>>;
+  compactSegments: Type.TOptional<Type.TArray<Type.TObject<{
+    text: Type.TString;
+    color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"mdCode">, Type.TLiteral<"toolDiffAdded">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"syntaxNumber">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+  }>>>;
+  placement: Type.TOptional<Type.TUnion<[Type.TLiteral<"modeline">, Type.TLiteral<"beforeModel">]>>;
+  order: Type.TInteger;
+}>;
+export type FooterStatusItem = Static<typeof FooterStatusItemSchema>;
+export interface DoomFooterContributionDefinition {
+  source: string;
+  id: string;
+  order: number;
+  placement?: FooterStatusPlacement;
+}
+export interface DoomFooterContributionValue {
+  fullText: string;
+  compactText: string;
+  fullSegments?: FooterTextSegment[];
+  compactSegments?: FooterTextSegment[];
+}
+export interface DoomFooterContributionHandle {
+  update(value: DoomFooterContributionValue | undefined): void;
+  dispose(): void;
+}
+export interface DoomFooterStatus extends FooterStatusItem {
+  source: string;
+}
+//#endregion
+//# sourceMappingURL=footer.d.mts.map

package/dist/src/schemas/footer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.d.mts","names":[],"sources":["../../../src/schemas/footer.ts"],"mappings":";;qBAEa,uBAAqB,KAAA,QAAA,KAAA,oBAAA,KAAA,oBAAA,KAAA,2BAAA,KAAA,qBAAA,KAAA,uBAAA,KAAA,0BAAA,KAAA,mBAAA,KAAA;YAUtB,kBAAkB,cAAc;qBAE/B,6BAA2B,KAAA,QAAA,KAAA,sBAAA,KAAA;YAC5B,wBAAwB,cAAc;qBAErC,yBAAuB,KAAA;;;;YAOxB,oBAAoB,cAAc;qBAEjC,wBAAsB,KAAA;;;;;;;;;;;;;;;YAYvB,mBAAmB,cAAc;iBAE5B;EACf;EACA;EACA;EACA,YAAY;;iBAGG;EACf;EACA;EACA,eAAe;EACf,kBAAkB;;iBAGH;EACf,OAAO,OAAO;EACd;;iBAGe,yBAAyB;EACxC"}

package/dist/src/schemas/footer.mjs

@@ -0,0 +1,45 @@
+import { Type } from "typebox";
+//#region src/schemas/footer.ts
+const FooterTextColorSchema = Type.Union([
+	Type.Literal("accent"),
+	Type.Literal("mdCode"),
+	Type.Literal("toolDiffAdded"),
+	Type.Literal("warning"),
+	Type.Literal("mdHeading"),
+	Type.Literal("syntaxNumber"),
+	Type.Literal("muted"),
+	Type.Literal("dim")
+]);
+const FooterStatusPlacementSchema = Type.Union([Type.Literal("modeline"), Type.Literal("beforeModel")]);
+const FooterTextSegmentSchema = Type.Object({
+	text: Type.String({
+		minLength: 1,
+		maxLength: 80
+	}),
+	color: Type.Optional(FooterTextColorSchema)
+}, { additionalProperties: false });
+const FooterStatusItemSchema = Type.Object({
+	id: Type.String({
+		minLength: 1,
+		maxLength: 128
+	}),
+	fullText: Type.String({
+		minLength: 1,
+		maxLength: 80
+	}),
+	compactText: Type.String({
+		minLength: 1,
+		maxLength: 24
+	}),
+	fullSegments: Type.Optional(Type.Array(FooterTextSegmentSchema, { maxItems: 80 })),
+	compactSegments: Type.Optional(Type.Array(FooterTextSegmentSchema, { maxItems: 24 })),
+	placement: Type.Optional(FooterStatusPlacementSchema),
+	order: Type.Integer({
+		minimum: 0,
+		maximum: 1e3
+	})
+}, { additionalProperties: false });
+//#endregion
+export { FooterStatusItemSchema, FooterStatusPlacementSchema, FooterTextColorSchema, FooterTextSegmentSchema };
+
+//# sourceMappingURL=footer.mjs.map