@akanjs/cli 3.0.0-beta.19 → 3.0.0-beta.20

package/{index-3jrp517k.js → index-nv5976x3.js}

@@ -1,14 +1,13 @@
 // @bun
 import {
   AppExecutor
-} from "./index-crmeqnmf.js";
+} from "./index-9d9bgcx4.js";
 import {
   jsonText,
   createWorkflowBaselineSummary,
   buildAkanModuleContextIndex,
-  createWorkflowStepRegistry,
   toolingRolloutGate
-} from "./index-2446k7b4.js";
+} from "./index-myhc3c1j.js";
 import {
   buildResourceList,
   codexMcpConfigPath,
@@ -18,38 +17,29 @@ import {
   upsertCodexMcpServerBlock,
   renderDoctorText,
   AkanContextAnalyzer
-} from "./index-18zybgkc.js";
+} from "./index-ygn77a5w.js";
 import {
   isPlaceholderAppId2
-} from "./index-vqx8bdxz.js";
+} from "./index-mxav6j3c.js";
 import {
-  CommandContainer,
   runner
-} from "./index-qdgzsnhg.js";
+} from "./index-w2zdcw3k.js";
 import {
   Prompter2
-} from "./index-s5rhm04y.js";
+} from "./index-0bq14vr1.js";
 import {
   RepairRunner
-} from "./index-53176s7j.js";
+} from "./index-31yr441d.js";
 import {
   WorkflowRunner
-} from "./index-txr7dj2g.js";
-import {
-  ModuleScript
-} from "./index-esk82rvk.js";
-import {
-  PrimitiveScript
-} from "./index-zqgj2rt2.js";
-import {
-  ScalarScript
-} from "./index-4m929vvn.js";
+} from "./index-xqpzbab5.js";
 import {
   getMobileTargets
-} from "./index-47pj3aee.js";
+} from "./index-5e0n4hqx.js";
 
 // pkgs/@akanjs/devkit/akanMcpContract.ts
 import path from "path";
+import { isRecord } from "akanjs/common";
 var emptySchema = { type: "object", properties: {} };
 var stringProperty = { type: "string" };
 var booleanProperty = { type: "boolean" };
@@ -133,18 +123,11 @@ var inspectAkanContextInputSchema = {
   },
   required: ["question", "draft", "review", "request"]
 };
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var slugPart = (value) => typeof value === "string" ? value.trim().replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() : "";
 var optionalString = (args, key) => {
   const value = args[key];
   return typeof value === "string" && value ? value : undefined;
 };
-var nestedStringArg = (args, key) => {
-  const value = args[key];
-  if (typeof value !== "string" || !value)
-    throw new Error(`MCP tool argument "${key}" is required.`);
-  return value;
-};
 var isInspectAkanContextRequestType = (value) => typeof value === "string" && inspectAkanContextRequestTypes.includes(value);
 var parseJsonOutput = (output) => JSON.parse(output);
 var workspacePath = (workspace, filePath) => path.isAbsolute(filePath) ? filePath : path.join(workspace.workspaceRoot, filePath);
@@ -199,50 +182,31 @@ var inspectAkanContextPropsArg = (args) => {
   if (!isInspectAkanContextRequestType(args.request.type)) {
     throw new Error('MCP tool argument "request.type" must be a supported inspect_akan_context request type.');
   }
-  const draft = { reason: nestedStringArg(args.draft, "reason"), type: args.draft.type };
+  const base = { question, draft: { reason: stringArg(args.draft, "reason"), type: args.draft.type }, review };
   const request = args.request;
   if (request.type === "workspaceOverview")
-    return { question, draft, review, request: { type: request.type } };
+    return { ...base, request: { type: request.type } };
   if (request.type === "moduleContext")
     return {
-      question,
-      draft,
-      review,
-      request: {
-        type: request.type,
-        app: nestedStringArg(request, "app"),
-        module: nestedStringArg(request, "module")
-      }
+      ...base,
+      request: { type: request.type, app: stringArg(request, "app"), module: stringArg(request, "module") }
     };
   if (request.type === "fieldInsertionContext")
     return {
-      question,
-      draft,
-      review,
+      ...base,
       request: {
         type: request.type,
-        app: nestedStringArg(request, "app"),
-        module: nestedStringArg(request, "module"),
-        field: nestedStringArg(request, "field"),
-        fieldType: nestedStringArg(request, "fieldType")
+        app: stringArg(request, "app"),
+        module: stringArg(request, "module"),
+        field: stringArg(request, "field"),
+        fieldType: stringArg(request, "fieldType")
       }
     };
   if (request.type === "workflowDiagnostics")
-    return {
-      question,
-      draft,
-      review,
-      request: { type: request.type, runIdOrPlan: nestedStringArg(request, "runIdOrPlan") }
-    };
+    return { ...base, request: { type: request.type, runIdOrPlan: stringArg(request, "runIdOrPlan") } };
   return {
-    question,
-    draft,
-    review,
-    request: {
-      type: "escape",
-      reason: nestedStringArg(request, "reason"),
-      nextStep: optionalString(request, "nextStep")
-    }
+    ...base,
+    request: { type: "escape", reason: stringArg(request, "reason"), nextStep: optionalString(request, "nextStep") }
   };
 };
 var inspectDiagnostic = (severity, code, message) => ({ severity, code, message });
@@ -466,22 +430,11 @@ var inspectAkanContext = async (workspace, args) => {
       strict: true,
       runIdOrPlan: workspacePath(workspace, props.request.runIdOrPlan)
     });
-    const baselineSummary = createWorkflowBaselineSummary((doctor.baselineDiagnostics ?? []).map((diagnostic) => ({
-      severity: diagnostic.severity,
-      code: diagnostic.code,
-      message: diagnostic.message,
-      scope: diagnostic.scope,
-      context: diagnostic.context
-    })), { detailsIncluded: false });
-    diagnostics.push(...(doctor.workflowDiagnostics ?? doctor.diagnostics).map((diagnostic) => ({
-      severity: diagnostic.severity,
-      code: diagnostic.code,
-      message: diagnostic.message,
-      scope: diagnostic.scope,
-      context: {
-        ...diagnostic.context,
-        ...diagnostic.path ? { paths: [diagnostic.path] } : {}
-      }
+    const toWorkflowDiagnostic = ({ severity, code, message, scope }, context) => ({ severity, code, message, scope, context });
+    const baselineSummary = createWorkflowBaselineSummary((doctor.baselineDiagnostics ?? []).map((diagnostic) => toWorkflowDiagnostic(diagnostic, diagnostic.context)), { detailsIncluded: false });
+    diagnostics.push(...(doctor.workflowDiagnostics ?? doctor.diagnostics).map((diagnostic) => toWorkflowDiagnostic(diagnostic, {
+      ...diagnostic.context,
+      ...diagnostic.path ? { paths: [diagnostic.path] } : {}
     })));
     return baseResult("workflowDiagnostics", [
       {
@@ -499,9 +452,10 @@ var inspectAkanContext = async (workspace, args) => {
       workflowDiagnostics: doctor.workflowDiagnostics?.length ?? 0
     });
   }
+  const moduleRequest = props.request.type === "moduleContext" || props.request.type === "fieldInsertionContext" ? props.request : null;
   const context = await AkanContextAnalyzer.analyze(workspace, {
-    app: props.request.type === "moduleContext" || props.request.type === "fieldInsertionContext" ? props.request.app : null,
-    module: props.request.type === "moduleContext" || props.request.type === "fieldInsertionContext" ? props.request.module : null,
+    app: moduleRequest?.app ?? null,
+    module: moduleRequest?.module ?? null,
     includeAbstractContent: false
   });
   if (props.request.type === "workspaceOverview") {
@@ -589,41 +543,22 @@ var inspectAkanContext = async (workspace, args) => {
   });
 };
 
-// pkgs/@akanjs/cli/context/context.workflowRegistry.ts
-var createCliWorkflowStepRegistry = (workspace) => createWorkflowStepRegistry({
-  workspace,
-  createModule: (sys, module) => CommandContainer.get(ModuleScript).createModuleTemplate(sys, module),
-  createScalar: (sys, scalar) => CommandContainer.get(ScalarScript).createScalar(sys, scalar),
-  createUi: (input) => CommandContainer.get(PrimitiveScript).createUi(workspace, input),
-  addField: (input) => CommandContainer.get(PrimitiveScript).addField(workspace, input),
-  addEnumField: (input) => CommandContainer.get(PrimitiveScript).addEnumField(workspace, input),
-  addMutation: (input) => CommandContainer.get(PrimitiveScript).addMutation(workspace, input),
-  addSlice: (input) => CommandContainer.get(PrimitiveScript).addSlice(workspace, input)
-});
-
 // pkgs/@akanjs/cli/context/context.runner.ts
 var toolErrorText = (error) => {
   const message = error instanceof Error ? error.message : String(error);
   return message.replace(/\/(?:[^\s"'/]+\/)*(?=(?:pkgs|apps|libs|infra)\/)/g, "<workspace>/");
 };
-var workflowDiagnosticFromContext = (diagnostic) => ({
-  severity: diagnostic.severity,
-  code: diagnostic.code,
-  message: diagnostic.message,
-  scope: diagnostic.scope,
-  context: diagnostic.context
-});
 var compactDoctorWorkspaceResult = (result, includeBaselineDetails) => {
   const baselineDiagnostics = result.baselineDiagnostics ?? [];
-  if (baselineDiagnostics.length === 0) {
-    return {
-      ...result,
-      baselineSummary: createWorkflowBaselineSummary([], { detailsIncluded: includeBaselineDetails })
-    };
-  }
-  const baselineSummary = createWorkflowBaselineSummary(baselineDiagnostics.map(workflowDiagnosticFromContext), {
-    detailsIncluded: includeBaselineDetails
-  });
+  const baselineSummary = createWorkflowBaselineSummary(baselineDiagnostics.map(({ severity, code, message, scope, context }) => ({
+    severity,
+    code,
+    message,
+    scope,
+    context
+  })), { detailsIncluded: includeBaselineDetails });
+  if (baselineDiagnostics.length === 0)
+    return { ...result, baselineSummary };
   return {
     ...result,
     baselineSummary,
@@ -638,11 +573,7 @@ class ContextRunner2 extends runner("context") {
     app = null,
     module = null
   } = {}) {
-    const context = await AkanContextAnalyzer.analyze(workspace, {
-      app,
-      module,
-      includeAbstractContent: !!module
-    });
+    const context = await AkanContextAnalyzer.analyze(workspace, { app, module, includeAbstractContent: !!module });
     return format === "json" ? jsonText(context) : AkanContextAnalyzer.renderMarkdown(context, { module });
   }
   async doctor(workspace, {
@@ -705,13 +636,7 @@ class ContextRunner2 extends runner("context") {
     if (currentAkanServer && !force && JSON.stringify(currentAkanServer) !== JSON.stringify(nextAkanServer)) {
       throw new Error(`${configPath} already has an "akan" MCP server. Re-run with --force to overwrite it.`);
     }
-    const nextConfig = {
-      ...existing,
-      mcpServers: {
-        ...mcpServers,
-        akan: nextAkanServer
-      }
-    };
+    const nextConfig = { ...existing, mcpServers: { ...mcpServers, akan: nextAkanServer } };
     await workspace.writeFile(configPath, `${JSON.stringify(nextConfig, null, 2)}
 `);
     return configPath;
@@ -804,7 +729,7 @@ class ContextRunner2 extends runner("context") {
         format: "json",
         dryRun: !!args.dryRun,
         workspace,
-        registry: createCliWorkflowStepRegistry(workspace)
+        registry: WorkflowRunner.stepRegistry(workspace)
       }));
       const validationTarget = typeof report.validationTarget === "string" ? report.validationTarget : typeof report.applyReportPath === "string" ? report.applyReportPath : stringArg(args, "planPath");
       return {
@@ -897,22 +822,14 @@ ${payload}`);
           serverInfo: { name: "akan", version: process.env.AKAN_VERSION ?? "0.0.0" }
         }, framing);
       } else if (request.method === "tools/list") {
-        respond(request.id, {
-          tools: this.listMcpTools(mode, { guidelineNames })
-        }, framing);
+        respond(request.id, { tools: this.listMcpTools(mode, { guidelineNames }) }, framing);
       } else if (request.method === "tools/call") {
         const name = params.name;
         const args = params.arguments ?? {};
         try {
           const result = await this.callMcpTool(workspace, name, args, { mode });
-          respond(request.id, {
-            content: [
-              {
-                type: "text",
-                text: typeof result === "string" ? result : jsonText(result, { trailingNewline: false })
-              }
-            ]
-          }, framing);
+          const text = typeof result === "string" ? result : jsonText(result, { trailingNewline: false });
+          respond(request.id, { content: [{ type: "text", text }] }, framing);
         } catch (error) {
           respond(request.id, { content: [{ type: "text", text: toolErrorText(error) }], isError: true }, framing);
         }

package/{index-zqgj2rt2.js → index-przybvy5.js}

@@ -1,22 +1,22 @@
 // @bun
 import {
   script
-} from "./index-qdgzsnhg.js";
+} from "./index-w2zdcw3k.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-crmeqnmf.js";
+} from "./index-9d9bgcx4.js";
 import {
+  workflowStatus,
   compactDiagnostics,
-  createPrimitiveWriteReport,
   sourceFile,
   moduleComponentName,
   moduleSourcePaths,
   generatedFilesForSync,
   validationCommandsForTarget,
   nextActionsForTarget,
-  lowerlize,
+  createPrimitiveWriteReport,
   normalizeFieldType,
   ensureNamedImport,
   ensureBaseImport,
@@ -41,13 +41,13 @@ import {
   hasSignalFactoryEntry,
   insertSignalFactoryEntry,
   addFieldUiPolicyForType
-} from "./index-2446k7b4.js";
+} from "./index-myhc3c1j.js";
 import {
   ModuleScript
-} from "./index-esk82rvk.js";
+} from "./index-8mna0947.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
-import { capitalize } from "akanjs/common";
+import { capitalize, lowerlize } from "akanjs/common";
 class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async resolveSys(workspace, target) {
     if (!target)
@@ -61,28 +61,11 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   }
   async createUi(workspace, input) {
     const sys = await this.resolveSys(workspace, input.app);
-    if (!sys || !input.module) {
-      return createPrimitiveWriteReport({
-        command: "create-ui",
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics: compactDiagnostics([
-          !sys && {
-            severity: "error",
-            code: "primitive-target-missing",
-            message: "Target app or library was not found."
-          },
-          !input.module && {
-            severity: "error",
-            code: "primitive-input-missing",
-            message: "Module is required.",
-            input: "module"
-          }
-        ]),
-        nextActions: []
-      });
-    }
+    if (!sys || !input.module)
+      return PrimitiveScript.#refuse("create-ui", compactDiagnostics([
+        !sys && PrimitiveScript.#targetMissing(),
+        !input.module && PrimitiveScript.#inputMissing("module")
+      ]));
     const mod = ModuleExecutor.from(sys, input.module);
     if (input.surface === "view")
       return await this.moduleScript.createView(mod);
@@ -98,30 +81,16 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     return await this.addFieldToSources(workspace, { ...input, type: `${capitalize(input.field ?? "")}` }, { enumValues: values });
   }
   async addFieldToSources(workspace, input, { enumValues }) {
+    const command = enumValues ? "add-enum-field" : "add-field";
     const sys = await this.resolveSys(workspace, input.app);
     const ambiguousNumberTypes = new Set(["number", "numeric"]);
     const normalizedType = input.type ? normalizeFieldType(input.type) : null;
     const diagnostics = compactDiagnostics([
-      !sys && { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." },
-      !input.module && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Module is required.",
-        input: "module"
-      },
-      !input.field && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Field is required.",
-        input: "field"
-      },
-      !input.type && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Type is required.",
-        input: "type"
-      },
-      enumValues && enumValues.length === 0 ? { severity: "error", code: "primitive-input-missing", message: "Enum values are required.", input: "values" } : null,
+      !sys && PrimitiveScript.#targetMissing(),
+      !input.module && PrimitiveScript.#inputMissing("module"),
+      !input.field && PrimitiveScript.#inputMissing("field"),
+      !input.type && PrimitiveScript.#inputMissing("type"),
+      enumValues?.length === 0 && PrimitiveScript.#inputMissing("values", "Enum values are required."),
       input.type && ambiguousNumberTypes.has(input.type.toLowerCase()) ? {
         severity: "error",
         code: "primitive-field-type-unsupported",
@@ -135,16 +104,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         input: "type"
       } : null
     ]);
-    if (!sys || !input.module || !input.field || !input.type || diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: enumValues ? "add-enum-field" : "add-field",
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics,
-        nextActions: []
-      });
-    }
+    if (!sys || !input.module || !input.field || !input.type || workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#refuse(command, diagnostics);
     const moduleClassName = moduleComponentName(input.module);
     const inputClassName = `${moduleClassName}Input`;
     const paths = moduleSourcePaths(input.module);
@@ -152,32 +113,13 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     const dictionaryPath = paths.dictionary;
     const templatePath = paths.template;
     const changedFiles = [];
-    const generatedFiles = generatedFilesForSync(sys);
     const [hasConstant, hasDictionary] = await Promise.all([sys.exists(constantPath), sys.exists(dictionaryPath)]);
-    if (!hasConstant) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Constant source file was not found: ${constantPath}.`
-      });
-    }
-    if (!hasDictionary) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Dictionary source file was not found: ${dictionaryPath}.`
-      });
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: enumValues ? "add-enum-field" : "add-field",
-        changedFiles,
-        generatedFiles,
-        validationCommands: validationCommandsForTarget(sys.name),
-        diagnostics,
-        nextActions: nextActionsForTarget(sys.name)
-      });
-    }
+    if (!hasConstant)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Constant", constantPath));
+    if (!hasDictionary)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Dictionary", dictionaryPath));
+    if (workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#report(command, sys, changedFiles, diagnostics);
     let constantContent = await sys.readFile(constantPath);
     let dictionaryContent = await sys.readFile(dictionaryPath);
     const fieldBuilderName = viaBuilderParameterName(constantContent, inputClassName) ?? "field";
@@ -315,7 +257,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         }
       }
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextConstantContentWithLight && nextDictionaryContent) {
+    if (workflowStatus(diagnostics) === "passed" && nextConstantContentWithLight && nextDictionaryContent) {
       await sys.writeFile(constantPath, nextConstantContentWithLight);
       await sys.writeFile(dictionaryPath, nextDictionaryContent);
       changedFiles.push(sourceFile(sys, constantPath, "modify", "Field source shape was updated."), sourceFile(sys, dictionaryPath, "modify", "Field dictionary labels were updated."));
@@ -324,14 +266,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         changedFiles.push(sourceFile(sys, templatePath, "modify", "Template field surface was updated."));
       }
     }
-    return createPrimitiveWriteReport({
-      command: enumValues ? "add-enum-field" : "add-field",
-      changedFiles,
-      generatedFiles,
-      validationCommands: validationCommandsForTarget(sys.name),
-      diagnostics,
-      nextActions: nextActionsForTarget(sys.name)
-    });
+    return PrimitiveScript.#report(command, sys, changedFiles, diagnostics);
   }
   async addMutation(workspace, input) {
     const moduleClassName = input.module ? moduleComponentName(input.module) : "";
@@ -405,60 +340,21 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async#writeServiceSignalEntry(workspace, spec) {
     const sys = await this.resolveSys(workspace, spec.app);
     const diagnostics = compactDiagnostics([
-      !sys && { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." },
-      !spec.module && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Module is required.",
-        input: "module"
-      },
-      !spec.entryName && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: `${capitalize(spec.requiredInput)} name is required.`,
-        input: spec.requiredInput
-      }
+      !sys && PrimitiveScript.#targetMissing(),
+      !spec.module && PrimitiveScript.#inputMissing("module"),
+      !spec.entryName && PrimitiveScript.#inputMissing(spec.requiredInput, `${capitalize(spec.requiredInput)} name is required.`)
     ]);
-    if (!sys || !spec.module || !spec.entryName || !spec.serviceMethod || !spec.signal) {
-      return createPrimitiveWriteReport({
-        command: spec.command,
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics,
-        nextActions: []
-      });
-    }
-    const paths = moduleSourcePaths(spec.module);
-    const servicePath = paths.service;
-    const signalPath = paths.signal;
+    if (!sys || !spec.module || !spec.entryName || !spec.serviceMethod || !spec.signal)
+      return PrimitiveScript.#refuse(spec.command, diagnostics);
+    const { service: servicePath, signal: signalPath } = moduleSourcePaths(spec.module);
     const changedFiles = [];
-    const generatedFiles = generatedFilesForSync(sys);
     const [hasServiceFile, hasSignalFile] = await Promise.all([sys.exists(servicePath), sys.exists(signalPath)]);
-    if (!hasServiceFile) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Service source file was not found: ${servicePath}.`
-      });
-    }
-    if (!hasSignalFile) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Signal source file was not found: ${signalPath}.`
-      });
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: spec.command,
-        changedFiles,
-        generatedFiles,
-        validationCommands: validationCommandsForTarget(sys.name),
-        diagnostics,
-        nextActions: nextActionsForTarget(sys.name)
-      });
-    }
+    if (!hasServiceFile)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Service", servicePath));
+    if (!hasSignalFile)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Signal", signalPath));
+    if (workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#report(spec.command, sys, changedFiles, diagnostics);
     const serviceClassName = `${moduleComponentName(spec.module)}Service`;
     const serviceContent = await sys.readFile(servicePath);
     const signalContent = await sys.readFile(signalPath);
@@ -520,20 +416,46 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         message: `Edited ${signalPath} did not contain entry "${spec.entryName}" in ${spec.signal.className}.`
       });
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextServiceContent && nextSignalContent) {
+    if (workflowStatus(diagnostics) === "passed" && nextServiceContent && nextSignalContent) {
       await sys.writeFile(servicePath, nextServiceContent);
       await sys.writeFile(signalPath, nextSignalContent);
       changedFiles.push(sourceFile(sys, servicePath, "modify", `Service ${spec.entryKind} was added.`), sourceFile(sys, signalPath, "modify", `Signal ${spec.entryKind} was added.`));
     }
+    return PrimitiveScript.#report(spec.command, sys, changedFiles, diagnostics);
+  }
+  static #refuse(command, diagnostics) {
+    return createPrimitiveWriteReport({
+      command,
+      changedFiles: [],
+      generatedFiles: [],
+      validationCommands: [],
+      diagnostics,
+      nextActions: []
+    });
+  }
+  static #report(command, sys, changedFiles, diagnostics) {
     return createPrimitiveWriteReport({
-      command: spec.command,
+      command,
       changedFiles,
-      generatedFiles,
+      generatedFiles: generatedFilesForSync(sys),
       validationCommands: validationCommandsForTarget(sys.name),
       diagnostics,
       nextActions: nextActionsForTarget(sys.name)
     });
   }
+  static #targetMissing() {
+    return { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." };
+  }
+  static #inputMissing(input, message = `${capitalize(input)} is required.`) {
+    return { severity: "error", code: "primitive-input-missing", message, input };
+  }
+  static #sourceMissing(kind, path) {
+    return {
+      severity: "error",
+      code: "primitive-source-missing",
+      message: `${kind} source file was not found: ${path}.`
+    };
+  }
 }
 
 export { PrimitiveScript };

package/{index-n3cv0tm4.js → index-smme4r47.js}

@@ -2,7 +2,7 @@
 import {
   GlobalConfig,
   CloudApi
-} from "./index-srmay5jw.js";
+} from "./index-22d57v4c.js";
 
 // pkgs/@akanjs/cli/tunnel/TunnelShare.ts
 import { TunnelAgent } from "akanjs/server/tunnel";