@llblab/pi-actors 0.33.0 → 0.34.0

package/lib/command-templates.ts

@@ -1,7 +1,7 @@
 /**
- * Command-template standard helpers
- * Zones: shared utils, local process execution, automation standard
- * Owns shell-free command-template splitting, placeholder defaults, composition expansion, executable path expansion, and direct execution
+ * Command-template execution standard.
+ * Zones: shell-free command parsing, placeholder expansion, local process execution, composition semantics
+ * Owns portable command-template parsing, expansion, risk checks, retries, timeouts, and direct execution.
  */
 
 import { spawn } from "node:child_process";

package/lib/config.ts

@@ -10,7 +10,7 @@ import type { CommandTemplateValue } from "./command-templates.ts";
 import * as CommandTemplates from "./command-templates.ts";
 import { writeJsonAtomic } from "./file-state.ts";
 import { normalizeToolName } from "./identity.ts";
-import * as RecipeReferences from "./recipe-references.ts";
+import * as RecipesReferences from "./recipes-references.ts";
 import * as Schema from "./schema.ts";
 
 export interface RegisteredTool {
@@ -19,7 +19,7 @@ export interface RegisteredTool {
   args: string[];
   defaults: Record<string, string>;
   argTypes?: Record<string, Schema.ToolArgType>;
-  recipe?: RecipeReferences.TemplateRecipeConfig;
+  recipe?: RecipesReferences.TemplateRecipeConfig;
   template?: CommandTemplateValue;
   storedArgs?: string[];
   storedDefaults?: Record<string, string>;
@@ -141,7 +141,7 @@ export function normalizeStoredTool(
   }
   const recipeName =
     keyedRecipeName ?? (typeof record.async === "boolean" ? name : undefined);
-  const recipe: RecipeReferences.TemplateRecipeConfig | undefined = recipeName
+  const recipe: RecipesReferences.TemplateRecipeConfig | undefined = recipeName
     ? {
         name: recipeName,
         ...(typeof record.async === "boolean" ? { async: record.async } : {}),
@@ -156,14 +156,14 @@ export function normalizeStoredTool(
           : {}),
       }
     : undefined;
-  const isRecipe = RecipeReferences.isRecipeTool(template, recipe);
-  const recipeTemplate = RecipeReferences.getRecipeTemplate(template);
+  const isRecipe = RecipesReferences.isRecipeTool(template, recipe);
+  const recipeTemplate = RecipesReferences.getRecipeTemplate(template);
   const argTemplate = recipeTemplate ?? template;
   const description =
     typeof record.description === "string" && record.description.trim()
       ? record.description.trim()
       : isRecipe
-        ? `${recipe?.async === true || RecipeReferences.isAsyncRecipeReference(template) ? "Start async" : "Execute"} template recipe: ${recipe?.name ?? formatTemplateForDescription(template)}`
+        ? `${recipe?.async === true || RecipesReferences.isAsyncRecipeReference(template) ? "Start async" : "Execute"} template recipe: ${recipe?.name ?? formatTemplateForDescription(template)}`
         : `Execute command template: ${formatTemplateForDescription(template)}`;
   const declarations = Schema.normalizeStoredToolArgDeclarations(
     record.args,
@@ -199,7 +199,7 @@ export function normalizeStoredTool(
     args:
       isRecipe && storedArgs !== undefined
         ? Schema.getExplicitToolArgNames(storedArgs)
-        : RecipeReferences.isRecipeReference(template) && !recipeTemplate
+        : RecipesReferences.isRecipeReference(template) && !recipeTemplate
           ? Schema.getExplicitToolArgNames(storedArgs)
           : Schema.getToolArgNames(argTemplateConfig),
     defaults: declarations.defaults,

package/lib/{output.ts → execution-output.ts}

@@ -1,7 +1,7 @@
 /**
- * Tool output formatting helpers
- * Zones: tool execution, output formatting, temp artifacts
- * Owns stdout/stderr failure formatting, tail truncation, and full-output temp-file persistence
+ * Registered tool execution output.
+ * Zones: command execution results, bounded output formatting, temp artifacts
+ * Owns stdout/stderr failure formatting, tail truncation, and full-output temp-file persistence.
  */
 
 import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";

package/lib/execution.ts

@@ -6,7 +6,11 @@
 
 import * as CommandTemplates from "./command-templates.ts";
 import type { RegisteredTool } from "./config.ts";
-import { formatFailureOutput, formatOutput, formatToolText } from "./output.ts";
+import {
+  formatFailureOutput,
+  formatOutput,
+  formatToolText,
+} from "./execution-output.ts";
 import * as Schema from "./schema.ts";
 
 export interface ToolExecOptions {

package/lib/{actor-inspector-tui.ts → inspector.ts}

@@ -1,6 +1,7 @@
 /**
- * Actor inspector TUI previews.
- * Zones: terminal actor inspection, room/direct message previews, no-dependency UI formatting
+ * Inspector preview rendering.
+ * Zones: terminal run inspection, room/direct message previews, no-dependency UI formatting
+ * Owns read-only previews and TUI-ready summaries; actor routing stays outside.
  */
 
 import * as fs from "node:fs";
@@ -8,7 +9,7 @@ import * as path from "node:path";
 
 import { visibleWidth } from "@earendil-works/pi-tui";
 
-import type { ActorMessage } from "./actor-messages.ts";
+import type { ActorMessage } from "./messages.ts";
 import * as Limits from "./limits.ts";
 import * as Paths from "./paths.ts";
 import {

package/lib/mailbox-loop.ts

@@ -1,14 +1,14 @@
 /**
- * Minimal mailbox loop helpers.
+ * Mailbox worker loop primitives.
  * Zones: mailbox-consuming actors, run/branch inbox claiming, handler status transitions
- * Owns small reusable primitives for recipe authors; scheduling and task policy stay outside.
+ * Owns reusable claim/handle/drain behavior across run and branch inboxes; scheduling and task policy stay outside.
  */
 
 import {
   claimBranchInboxMessage,
   updateBranchInboxMessageStatus,
   type BranchInboxRecord,
-} from "./actor-rooms.ts";
+} from "./rooms.ts";
 import {
   claimRunInboxMessage,
   updateRunInboxMessageStatus,

package/lib/{actor-messages.ts → messages.ts}

@@ -1,7 +1,7 @@
 /**
- * Actor message protocol helpers.
- * Zones: 0.10 draft communication protocol, addressed messages, mailbox metadata
- * Owns pure validation/normalization for the semantic message envelope; transport routing stays in adapters.
+ * Actor message protocol.
+ * Zones: addressed envelopes, address parsing, route normalization
+ * Owns pure validation/normalization for semantic actor messages; transport routing stays in adapters.
  */
 
 export type ActorAddressKind =

package/lib/{actor-recipe-context.ts → recipes-context.ts}

@@ -1,12 +1,13 @@
 /**
- * Actor recipe context prompt helpers.
+ * Recipe context prompt assembly.
  * Zones: async runner prompt context, recipe provenance, LLM child launches
+ * Owns compact actor recipe context records appended to child-agent prompts.
  */
 
 import { basename } from "node:path";
 
 import type { CommandTemplateActorRecipeContext } from "./command-templates.ts";
-import type { TemplateRecipeContextRecord } from "./recipe-references.ts";
+import type { TemplateRecipeContextRecord } from "./recipes-references.ts";
 
 export interface MarkedRecipeContextRecord extends TemplateRecipeContextRecord {
   you_are_here?: true;

package/lib/{recipe-discovery.ts → recipes-discovery.ts}

@@ -10,8 +10,8 @@ import { join } from "node:path";
 
 import * as CommandTemplates from "./command-templates.ts";
 import type { RegisteredTool } from "./config.ts";
-import type { TemplateRecipeConfig } from "./recipe-references.ts";
-import * as RecipeReferences from "./recipe-references.ts";
+import type { TemplateRecipeConfig } from "./recipes-references.ts";
+import * as RecipesReferences from "./recipes-references.ts";
 import * as Schema from "./schema.ts";
 
 export interface DiscoveredRecipe {
@@ -43,13 +43,13 @@ export interface RecipeIntegrityManifestEntry {
   shadowed: boolean;
 }
 
-export interface RecipeDiscoveryResult {
+export interface RecipesDiscoveryResult {
   active: Map<string, DiscoveredRecipe>;
   entries: DiscoveredRecipe[];
   diagnostics: string[];
 }
 
-export interface RecipeDiscoverySource {
+export interface RecipesDiscoverySource {
   root?: string;
   file?: string;
   defaultTool?: boolean;
@@ -115,7 +115,7 @@ function getRecipeConfigDiagnostics(
   config: TemplateRecipeConfig | undefined,
 ): string[] {
   if (!config) {
-    const reason = RecipeReferences.diagnoseRawRecipeConfigFailure(file);
+    const reason = RecipesReferences.diagnoseRawRecipeConfigFailure(file);
     return [`Invalid recipe: ${file}${reason ? `: ${reason}` : ""}`];
   }
   const commandTemplateConfig =
@@ -134,9 +134,9 @@ function readDiscoveredRecipe(
   defaultTool = false,
   mutableUsage = false,
 ): DiscoveredRecipe {
-  const id = RecipeReferences.getRecipeIdFromPath(file);
+  const id = RecipesReferences.getRecipeIdFromPath(file);
   try {
-    const config = RecipeReferences.readResolvedRecipeConfig(file);
+    const config = RecipesReferences.readResolvedRecipeConfig(file);
     const invalid = !config;
     const disabled = config?.disabled === true;
     return {
@@ -174,7 +174,7 @@ function readDiscoveredRecipe(
   }
 }
 
-function filesForSource(source: RecipeDiscoverySource): Array<{
+function filesForSource(source: RecipesDiscoverySource): Array<{
   root: string;
   file: string;
   defaultTool: boolean;
@@ -201,7 +201,7 @@ function filesForSource(source: RecipeDiscoverySource): Array<{
     : [];
 }
 
-function getRecipeRootDiagnostics(sources: RecipeDiscoverySource[]): string[] {
+function getRecipeRootDiagnostics(sources: RecipesDiscoverySource[]): string[] {
   const diagnostics: string[] = [];
   const roots = new Set(
     sources
@@ -232,8 +232,8 @@ function getRecipeRootDiagnostics(sources: RecipeDiscoverySource[]): string[] {
 }
 
 export function discoverRecipeSources(
-  sources: RecipeDiscoverySource[],
-): RecipeDiscoveryResult {
+  sources: RecipesDiscoverySource[],
+): RecipesDiscoveryResult {
   const entries = sources.flatMap((source, priority) =>
     filesForSource(source).map(({ root, file, defaultTool, mutableUsage }) =>
       readDiscoveredRecipe(root, file, priority, defaultTool, mutableUsage),
@@ -286,7 +286,7 @@ export function discoverRecipeSources(
   return { active, entries, diagnostics };
 }
 
-export function discoverRecipes(roots: string[]): RecipeDiscoveryResult {
+export function discoverRecipes(roots: string[]): RecipesDiscoveryResult {
   return discoverRecipeSources(roots.map((root) => ({ root })));
 }
 
@@ -362,7 +362,7 @@ function cleanupRecommendation(
 }
 
 export function createRecipeIntegrityManifest(
-  result: RecipeDiscoveryResult,
+  result: RecipesDiscoveryResult,
 ): RecipeIntegrityManifestEntry[] {
   return result.entries
     .map((entry) => {
@@ -425,7 +425,7 @@ function diagnosticSuggestedAction(message: string): string {
 }
 
 function diagnosticDetails(
-  result: RecipeDiscoveryResult,
+  result: RecipesDiscoveryResult,
 ): Array<Record<string, unknown>> {
   const details: Array<Record<string, unknown>> = [];
   const seen = new Set<string>();
@@ -529,7 +529,7 @@ function remediationRank(item: Record<string, unknown>): number {
 }
 
 function discoveryRemediations(
-  result: RecipeDiscoveryResult,
+  result: RecipesDiscoveryResult,
 ): Array<Record<string, unknown>> {
   return result.entries
     .map((entry) =>
@@ -560,7 +560,7 @@ function recommendationForEntry(
 }
 
 export function getShadowedLaunchDiagnostic(
-  result: RecipeDiscoveryResult,
+  result: RecipesDiscoveryResult,
   id: string,
 ): Record<string, unknown> | undefined {
   const active = result.active.get(id.trim());
@@ -576,8 +576,8 @@ export function getShadowedLaunchDiagnostic(
 
 export function listDraftRecipes(root: string): Array<Record<string, unknown>> {
   return listRecipeFiles(root).map((path) => {
-    const id = RecipeReferences.getRecipeIdFromPath(path);
-    const config = RecipeReferences.readRawRecipeConfig(path);
+    const id = RecipesReferences.getRecipeIdFromPath(path);
+    const config = RecipesReferences.readRawRecipeConfig(path);
     return {
       id,
       path,
@@ -587,7 +587,7 @@ export function listDraftRecipes(root: string): Array<Record<string, unknown>> {
 }
 
 export function summarizeDiscovery(
-  result: RecipeDiscoveryResult,
+  result: RecipesDiscoveryResult,
 ): Record<string, unknown> {
   const recommendations = result.entries
     .map((entry) =>

package/lib/{recipe-usage.ts → recipes-usage.ts}

@@ -9,7 +9,7 @@ import { existsSync, readFileSync } from "node:fs";
 
 import { writeJsonAtomic } from "./file-state.ts";
 
-interface RecipeUsageRecord {
+interface RecipesUsageRecord {
   calls?: number;
   direct_calls?: number;
   fingerprint?: string;
@@ -62,7 +62,7 @@ export function recordRecipeLaunch(
   try {
     const raw = JSON.parse(readFileSync(path, "utf8"));
     if (!isRecord(raw)) return false;
-    const usage: RecipeUsageRecord = isRecord(raw.usage) ? raw.usage : {};
+    const usage: RecipesUsageRecord = isRecord(raw.usage) ? raw.usage : {};
     const fingerprint = getRecipeFingerprint(raw);
     const changed =
       typeof usage.fingerprint === "string" &&

package/lib/registry.ts

@@ -7,13 +7,13 @@
 import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 
-import * as Config from "./config.ts";
-import * as Identity from "./identity.ts";
-import * as Output from "./output.ts";
 import * as CommandTemplates from "./command-templates.ts";
+import * as Config from "./config.ts";
+import * as ExecutionOutput from "./execution-output.ts";
 import { writeJsonAtomic } from "./file-state.ts";
+import * as Identity from "./identity.ts";
 import * as Paths from "./paths.ts";
-import * as RecipeReferences from "./recipe-references.ts";
+import * as RecipesReferences from "./recipes-references.ts";
 import * as Schema from "./schema.ts";
 
 export interface RegisterToolInput {
@@ -71,7 +71,7 @@ function listTools<TContext>(
   return {
     content: [
       textContent(
-        Output.formatToolText(
+        ExecutionOutput.formatToolText(
           names.length > 0
             ? `Registered tools:\n${names.map((name) => `- ${name}`).join("\n")}`
             : "No registered tools.",
@@ -122,7 +122,9 @@ function deleteTool<TContext>(
   if (!tools.has(name)) {
     return {
       content: [
-        textContent(Output.formatToolText(`Tool "${name}" not found.`)),
+        textContent(
+          ExecutionOutput.formatToolText(`Tool "${name}" not found.`),
+        ),
       ],
       details: { tool: name },
     };
@@ -137,7 +139,7 @@ function deleteTool<TContext>(
   return {
     content: [
       textContent(
-        Output.formatToolText(
+        ExecutionOutput.formatToolText(
           `Deleted tool "${name}". Reload to remove it from the complete registry.`,
         ),
       ),
@@ -157,7 +159,7 @@ function getInputTemplate(
     });
     if (steps.length === 0)
       throw new Error(
-        Output.formatToolText("Tool template sequence is empty."),
+        ExecutionOutput.formatToolText("Tool template sequence is empty."),
       );
     return value;
   }
@@ -168,7 +170,9 @@ function getInputTemplate(
     return value as CommandTemplates.CommandTemplateConfig;
   }
   throw new Error(
-    Output.formatToolText("Tool template must be a string, object, or sequence."),
+    ExecutionOutput.formatToolText(
+      "Tool template must be a string, object, or sequence.",
+    ),
   );
 }
 
@@ -182,26 +186,30 @@ function buildConfig(
       ? undefined
       : Schema.parseToolArgDeclarations(input.args);
   if (explicitArgs?.error)
-    throw new Error(Output.formatToolText(explicitArgs.error));
+    throw new Error(ExecutionOutput.formatToolText(explicitArgs.error));
   const description = (input.description ?? existing?.description ?? "").trim();
   if (!description) {
     throw new Error(
-      Output.formatToolText("Tool description is required unless deleting."),
+      ExecutionOutput.formatToolText(
+        "Tool description is required unless deleting.",
+      ),
     );
   }
   const template = getInputTemplate(input.template);
   if (template === null) {
     throw new Error(
-      Output.formatToolText("Tool template cannot be null here."),
+      ExecutionOutput.formatToolText("Tool template cannot be null here."),
     );
   }
   const finalTemplate =
     template === undefined || template === "" ? existing?.template : template;
   if (!finalTemplate) {
-    throw new Error(Output.formatToolText("Tool template is required."));
+    throw new Error(
+      ExecutionOutput.formatToolText("Tool template is required."),
+    );
   }
   const inputRecipe = typeof input.async === "boolean" ? name : undefined;
-  const recipe: RecipeReferences.TemplateRecipeConfig | undefined = inputRecipe
+  const recipe: RecipesReferences.TemplateRecipeConfig | undefined = inputRecipe
     ? {
         name: inputRecipe,
         ...(typeof input.async === "boolean" ? { async: input.async } : {}),
@@ -222,7 +230,7 @@ function buildConfig(
     : existing?.storedArgs;
   const storedDefaults =
     Object.keys(defaults).length > 0 ? defaults : undefined;
-  const recipeTemplate = RecipeReferences.getRecipeTemplate(finalTemplate);
+  const recipeTemplate = RecipesReferences.getRecipeTemplate(finalTemplate);
   const argTemplate = recipeTemplate ?? finalTemplate;
   const argTemplateConfig: CommandTemplates.CommandTemplateConfig =
     typeof argTemplate === "object" && !Array.isArray(argTemplate)
@@ -248,10 +256,10 @@ function buildConfig(
     template: finalTemplate,
     ...(recipe ? { recipe } : {}),
     args:
-      RecipeReferences.isRecipeTool(finalTemplate, recipe) &&
+      RecipesReferences.isRecipeTool(finalTemplate, recipe) &&
       storedArgs !== undefined
         ? Schema.getExplicitToolArgNames(storedArgs)
-        : RecipeReferences.isRecipeReference(finalTemplate) && !recipeTemplate
+        : RecipesReferences.isRecipeReference(finalTemplate) && !recipeTemplate
           ? Schema.getExplicitToolArgNames(storedArgs)
           : Schema.getToolArgNames(argTemplateConfig),
     defaults,
@@ -269,9 +277,12 @@ export async function executeRegisterTool<TContext>(
   const input = params as RegisterToolInput;
   if (!input.name) return listTools(deps);
   const name = Identity.normalizeToolName(input.name);
-  if (!name) throw new Error(Output.formatToolText("Invalid tool name."));
+  if (!name)
+    throw new Error(ExecutionOutput.formatToolText("Invalid tool name."));
   if (deps.reservedToolNames.has(name)) {
-    throw new Error(Output.formatToolText(`Reserved tool name: ${name}`));
+    throw new Error(
+      ExecutionOutput.formatToolText(`Reserved tool name: ${name}`),
+    );
   }
   const templateProvided = Object.hasOwn(input, "template");
   const template = getInputTemplate(input.template);
@@ -280,17 +291,19 @@ export async function executeRegisterTool<TContext>(
   const tools = deps.getTools();
   const existing = tools.get(name);
   const conflict = deps.getExternalToolConflict(name);
-  if (conflict) throw new Error(Output.formatToolText(conflict));
+  if (conflict) throw new Error(ExecutionOutput.formatToolText(conflict));
   if (existing && !input.update) {
     throw new Error(
-      Output.formatToolText(
+      ExecutionOutput.formatToolText(
         `Tool "${name}" already registered. Use update=true to overwrite.`,
       ),
     );
   }
   if (template === undefined && !existing) {
     throw new Error(
-      Output.formatToolText("Tool template is required for new registrations."),
+      ExecutionOutput.formatToolText(
+        "Tool template is required for new registrations.",
+      ),
     );
   }
   const cfg = buildConfig(name, input, existing);
@@ -299,7 +312,7 @@ export async function executeRegisterTool<TContext>(
     recipePath = persistToolRecipe(deps, cfg);
   } catch (error) {
     throw new Error(
-      Output.formatToolText(
+      ExecutionOutput.formatToolText(
         `Failed to persist tool recipe: ${error instanceof Error ? error.message : String(error)}`,
       ),
     );
@@ -320,7 +333,7 @@ export async function executeRegisterTool<TContext>(
   return {
     content: [
       textContent(
-        Output.formatToolText(
+        ExecutionOutput.formatToolText(
           `${existing ? "Updated" : "Registered"} tool "${name}" (args: ${Schema.formatToolArgs(cfg.args)}).${warningText}`,
         ),
       ),

package/lib/{actor-rooms.ts → rooms.ts}

@@ -1,14 +1,14 @@
 /**
- * Actor room persistence helpers.
- * Zones: room timelines, room rosters, cross-branch discovery state
- * Owns small file-backed room state; routing policy stays in tools/runtime adapters.
+ * Actor room persistence.
+ * Zones: room timelines, rosters, branch inboxes, cross-branch discovery state
+ * Owns file-backed room and branch-mailbox state; routing policy stays in tools/runtime adapters.
  */
 
 import * as fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 
-import type { ActorMessage } from "./actor-messages.ts";
+import type { ActorMessage } from "./messages.ts";
 import * as Limits from "./limits.ts";
 import { notifyRuntimeWake } from "./runtime-notifier.ts";
 import {

package/lib/runs-artifacts.ts

@@ -0,0 +1,96 @@
+/**
+ * Async run artifact declarations and manifest resolution.
+ * Owns artifact path template expansion and filesystem-backed artifact metadata.
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+
+import { substituteCommandTemplateToken } from "./command-templates.ts";
+
+export type RunArtifactDeclaration =
+  | string
+  | { path: string; kind?: string; media_type?: string; required?: boolean };
+
+export interface RunArtifactManifestEntry {
+  exists: boolean;
+  kind?: string;
+  media_type?: string;
+  path: string;
+  required?: boolean;
+  sha256?: string;
+  size?: number;
+}
+
+export function resolveArtifactPaths(
+  artifacts: Record<string, RunArtifactDeclaration> | undefined,
+  values: Record<string, unknown>,
+): Record<string, RunArtifactDeclaration> | undefined {
+  if (!artifacts) return undefined;
+  const resolved: Record<string, RunArtifactDeclaration> = {};
+  for (const [key, value] of Object.entries(artifacts)) {
+    if (!key.trim()) continue;
+    if (typeof value === "string") {
+      resolved[key] = substituteCommandTemplateToken(
+        value,
+        values,
+        `recipe artifacts.${key}`,
+      );
+    } else if (
+      value &&
+      typeof value === "object" &&
+      typeof value.path === "string"
+    ) {
+      resolved[key] = {
+        ...value,
+        path: substituteCommandTemplateToken(
+          value.path,
+          values,
+          `recipe artifacts.${key}.path`,
+        ),
+      };
+    }
+  }
+  return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+
+export function resolveArtifactManifest(
+  artifacts: Record<string, RunArtifactDeclaration> | undefined,
+): Record<string, RunArtifactManifestEntry> | undefined {
+  if (!artifacts) return undefined;
+  const manifest: Record<string, RunArtifactManifestEntry> = {};
+  for (const [name, artifact] of Object.entries(artifacts)) {
+    const declaration =
+      typeof artifact === "string" ? { path: artifact } : artifact;
+    if (!declaration?.path) continue;
+    try {
+      const content = readFileSync(declaration.path);
+      manifest[name] = {
+        exists: true,
+        ...(declaration.kind ? { kind: declaration.kind } : {}),
+        ...(declaration.media_type
+          ? { media_type: declaration.media_type }
+          : {}),
+        path: declaration.path,
+        ...(declaration.required !== undefined
+          ? { required: declaration.required }
+          : {}),
+        sha256: createHash("sha256").update(content).digest("hex"),
+        size: content.byteLength,
+      };
+    } catch {
+      manifest[name] = {
+        exists: false,
+        ...(declaration.kind ? { kind: declaration.kind } : {}),
+        ...(declaration.media_type
+          ? { media_type: declaration.media_type }
+          : {}),
+        path: declaration.path,
+        ...(declaration.required !== undefined
+          ? { required: declaration.required }
+          : {}),
+      };
+    }
+  }
+  return Object.keys(manifest).length > 0 ? manifest : undefined;
+}