@ykdz/template 0.0.38 → 0.0.40

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/publication/readiness.ts

@@ -584,15 +584,19 @@ function addManifestBlockers(options: {
     "imports",
     "provenance",
   ].filter((field) => Object.hasOwn(manifest, field));
+  const runtimeDependencies = manifest.dependencies;
   const manifestContractValid =
     manifest.type === "module" &&
     exactStringSet(manifest.files, publicationFiles) &&
     expectedPublicNodeRangeFromRoot !== undefined &&
     isObject(manifest.engines) &&
     manifest.engines.node === expectedPublicNodeRangeFromRoot &&
-    validRecordOfStrings(manifest.dependencies) &&
-    typeof manifest.dependencies.commander === "string" &&
-    manifest.dependencies.commander.trim().length > 0 &&
+    validRecordOfStrings(runtimeDependencies) &&
+    ["@ykdz/cli-contract", "@valibot/to-json-schema", "valibot"].every(
+      (name) =>
+        typeof runtimeDependencies[name] === "string" &&
+        runtimeDependencies[name].trim().length > 0,
+    ) &&
     isObject(scripts) &&
     typeof scripts.build === "string" &&
     scripts.build.length > 0 &&

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/src/cli.ts

@@ -1,27 +1,17 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 
+import { nodeCliOutput } from "@ykdz/cli-contract/node";
+
 import { cliCommandIdentity } from "./cli-command-identity.ts";
-import { runCli, type CliRuntime } from "./main.ts";
+import { runCli } from "./main.ts";
 
 const require = createRequire(import.meta.url);
-const packageManifest = require("../package.json") as unknown;
-
-const runtime: CliRuntime = {
+process.exitCode = await runCli({
   argv: process.argv,
-  streams: {
-    stdin: process.stdin,
-    stdout: process.stdout,
-    stderr: process.stderr,
+  write: nodeCliOutput({ stdout: process.stdout, stderr: process.stderr }),
+  // 身份读取和校验也使用 runCli 的意外故障出口。
+  get identity() {
+    return cliCommandIdentity(require("../package.json"));
   },
-  cwd: process.cwd(),
-  env: process.env,
-  tty: {
-    stdin: Boolean(process.stdin.isTTY),
-    stdout: Boolean(process.stdout.isTTY),
-    stderr: Boolean(process.stderr.isTTY),
-  },
-  identity: cliCommandIdentity(packageManifest),
-};
-
-process.exitCode = await runCli(runtime);
+});

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/src/main.ts

@@ -1,78 +1,162 @@
-import { Command, CommanderError } from "commander";
+import {
+  CliWriteError,
+  defineCli,
+  executeCli,
+  helpCapability,
+  outputCapability,
+  parseCliInvocation,
+  text,
+  versionCapability,
+  type WriteCliOutput,
+} from "@ykdz/cli-contract";
+import { isNodeBrokenPipe } from "@ykdz/cli-contract/node";
+import * as v from "valibot";
 
 import type { CliCommandIdentity } from "./cli-command-identity.ts";
-
-export type Greeting = {
-  readonly message: string;
-};
+import { standardSchema } from "./standard-schema.ts";
 
 export type CliRuntime = {
   readonly argv: readonly string[];
-  readonly streams: {
-    readonly stdin: object;
-    readonly stdout: { write(chunk: string): unknown };
-    readonly stderr: { write(chunk: string): unknown };
-  };
-  readonly cwd: string;
-  readonly env: Readonly<Record<string, string | undefined>>;
-  readonly tty: {
-    readonly stdin: boolean;
-    readonly stdout: boolean;
-    readonly stderr: boolean;
-  };
+  readonly write: WriteCliOutput;
   readonly identity: CliCommandIdentity;
 };
 
-export function greet(name: string): Greeting {
-  const normalizedName = name.trim();
-  if (normalizedName.length === 0) {
-    throw new Error("Name must not be empty");
-  }
-  return { message: `Hello, ${normalizedName}` };
-}
+const records = [
+  { name: "ada", title: "Ada Lovelace" },
+  { name: "grace", title: "Grace Hopper" },
+];
 
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-export function createCliCommand(runtime: CliRuntime): Command {
-  const command = new Command()
-    .name(runtime.identity.commandName)
-    .description("A TypeScript command-line tool.")
-    .version(runtime.identity.version)
-    .configureOutput({
-      writeOut: (text) => runtime.streams.stdout.write(text),
-      writeErr: (text) => runtime.streams.stderr.write(text),
-    })
-    .showHelpAfterError()
-    .exitOverride();
-  const greetCommand = command
-    .command("greet")
-    .description("Greet a person.")
-    .argument("<name>", "name to greet")
-    .action((name: string) => {
-      try {
-        runtime.streams.stdout.write(`${greet(name).message}\n`);
-      } catch (error) {
-        greetCommand.error(`error: ${errorMessage(error)}`, {
-          exitCode: 1,
-          code: "cli.greet.invalid-name",
-        });
-      }
-    });
-  return command;
+function createCliContract(identity: CliCommandIdentity) {
+  const define = defineCli<{ getManifest(): Record<string, unknown> }>();
+  return define({
+    root: "cli",
+    help: helpCapability({
+      shortAlias: "-h",
+      headings: {
+        usage: "用法",
+        commands: "命令",
+        arguments: "参数",
+        options: "选项",
+      },
+      wording: {
+        commandPlaceholder: "命令",
+        choices: "候选：{choices}",
+        default: "默认：{value}",
+      },
+    }),
+    version: versionCapability({
+      value: text.line(`${identity.commandName} ${identity.version}`),
+      shortAlias: "-V",
+    }),
+    output: outputCapability({ defaultFormat: "structured", text: true }),
+    usageFailureExitCode: 2,
+    commands: {
+      cli: {
+        kind: "rootGroup",
+        name: identity.commandName,
+        description: "查询示例记录。",
+      },
+      ...define.command("lookup")({
+        kind: "command",
+        parent: "cli",
+        name: "lookup",
+        description: "按名称查询内存记录。",
+        fields: {
+          name: { kind: "positional", description: "小写字母组成的记录名称" },
+        },
+        input: standardSchema(
+          v.object({
+            name: v.pipe(
+              v.string(),
+              v.regex(/^[a-z]+$/, "名称只能包含小写字母。"),
+            ),
+          }),
+        ),
+        success: {
+          kind: "data",
+          variants: {
+            found: {
+              description: "找到记录",
+              exitCode: 0,
+              schema: standardSchema(
+                v.object({ name: v.string(), title: v.string() }),
+              ),
+              text: ({ name, title }) =>
+                text.line(`找到记录：${title}（${name}）`),
+            },
+          },
+        },
+        failures: {
+          notFound: {
+            description: "记录不存在",
+            exitCode: 1,
+            schema: standardSchema(v.object({ name: v.string() })),
+            text: ({ name }) => text.line(`未找到记录：${name}。`),
+          },
+        },
+        handler({ input, outcome }) {
+          const record = records.find(({ name }) => name === input.name);
+          return record === undefined
+            ? outcome.failure.notFound({ name: input.name })
+            : outcome.data.found(record);
+        },
+      }),
+      ...define.command("schema")({
+        kind: "command",
+        parent: "cli",
+        name: "schema",
+        description: "导出完整 CLI 契约及输入/输出 Schema。",
+        input: standardSchema(v.object({})),
+        fields: {},
+        success: {
+          kind: "data",
+          variants: {
+            exported: {
+              description: "完整 CLI 契约",
+              exitCode: 0,
+              schema: standardSchema(
+                v.object({ manifest: v.record(v.string(), v.unknown()) }),
+              ),
+              text: ({ manifest }) =>
+                text.lines([
+                  "CLI 契约",
+                  ...JSON.stringify(manifest, null, 2).split("\n"),
+                ]),
+            },
+          },
+        },
+        failures: {},
+        handler: ({ dependencies, outcome }) =>
+          outcome.data.exported({ manifest: dependencies.getManifest() }),
+      }),
+    },
+  });
 }
 
 export async function runCli(runtime: CliRuntime): Promise<number> {
   try {
-    await createCliCommand(runtime).parseAsync([...runtime.argv], {
-      from: "node",
+    const contract = createCliContract(runtime.identity);
+    const result = await executeCli(contract, {
+      invocation: parseCliInvocation(contract, runtime.argv.slice(2)),
+      dependencies: { getManifest: () => ({ ...contract.manifest }) },
+      write: runtime.write,
     });
-    return 0;
+    return result.exitCode;
   } catch (error) {
-    if (error instanceof CommanderError) {
-      return error.exitCode;
+    if (
+      error instanceof CliWriteError &&
+      error.destination === "stdout" &&
+      isNodeBrokenPipe(error)
+    )
+      return 0;
+    try {
+      await runtime.write({
+        destination: "stderr",
+        chunk: "命令执行失败；请检查运行环境或报告此问题。\n",
+      });
+    } catch {
+      // 诊断通道故障不能改变原定退出类别。
     }
-    throw error;
+    return 70;
   }
 }

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/src/standard-schema.ts

@@ -0,0 +1,37 @@
+import { toStandardJsonSchema } from "@valibot/to-json-schema";
+import type * as v from "valibot";
+
+/** 上游执行器要求失败结果不带 value；保留 Valibot 的验证及官方 JSON Schema 投影。 */
+export function standardSchema<
+  T extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>,
+>(schema: T, ignoreActions: string[] = []) {
+  const converted = toStandardJsonSchema(schema);
+  const adapted: typeof converted = {
+    "~standard": {
+      ...converted["~standard"],
+      jsonSchema: {
+        input: (options) =>
+          converted["~standard"].jsonSchema.input({
+            ...options,
+            libraryOptions: { ...options.libraryOptions, ignoreActions },
+          }),
+        output: (options) =>
+          converted["~standard"].jsonSchema.output({
+            ...options,
+            libraryOptions: { ...options.libraryOptions, ignoreActions },
+          }),
+      },
+      validate(value) {
+        const result = converted["~standard"].validate(value);
+        if (result instanceof Promise)
+          return result.then((resolved) =>
+            resolved.issues === undefined
+              ? resolved
+              : { issues: resolved.issues },
+          );
+        return result.issues === undefined ? result : { issues: result.issues };
+      },
+    },
+  };
+  return adapted;
+}

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/test/e2e/journeys/lookup.journey.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import { cliCommandIdentity } from "../../../src/cli-command-identity.ts";
+import type { CliJourney } from "../journey.ts";
+
+const journey: CliJourney = {
+  name: "lookup",
+  modes: ["source", "distribution", "packed"],
+  async setup() {},
+  commands() {
+    return [
+      { name: "查询记录", args: ["lookup", "ada"] },
+      { name: "文本查询", args: ["lookup", "ada", "--output-format", "text"] },
+      { name: "未找到记录", args: ["lookup", "missing"] },
+      {
+        name: "文本失败",
+        args: ["lookup", "missing", "--output-format", "text"],
+      },
+      { name: "非法输入", args: ["lookup", "   ", "--output-format", "text"] },
+      { name: "完整契约", args: ["schema"] },
+      { name: "帮助", args: ["--help"] },
+      { name: "版本", args: ["--version"] },
+    ];
+  },
+  async assertions({ context, results }) {
+    const identity = cliCommandIdentity(
+      JSON.parse(
+        await readFile(path.join(context.packageRoot, "package.json"), "utf8"),
+      ),
+    );
+    assert.equal(results[0]?.exitCode, 0);
+    assert.equal(results[0]?.stderr, "");
+    assert.deepEqual(JSON.parse(results[0]?.stdout ?? ""), {
+      schemaVersion: "1",
+      command: "lookup",
+      kind: "data",
+      variant: "found",
+      data: { name: "ada", title: "Ada Lovelace" },
+    });
+    assert.equal(results[1]?.exitCode, 0);
+    assert.equal(results[1]?.stderr, "");
+    assert.match(results[1]?.stdout ?? "", /找到记录：Ada Lovelace/u);
+    for (const result of results.slice(2, 4)) {
+      assert.equal(result.exitCode, 1);
+      assert.equal(result.stdout, "");
+    }
+    assert.equal(JSON.parse(results[2]?.stderr ?? "").variant, "notFound");
+    assert.match(results[3]?.stderr ?? "", /未找到记录：missing/u);
+    assert.equal(results[4]?.exitCode, 2);
+    assert.equal(results[4]?.stdout, "");
+    assert.equal(JSON.parse(results[4]?.stderr ?? "").kind, "usageFailure");
+    for (const result of results.slice(5)) {
+      assert.equal(result.exitCode, 0);
+      assert.equal(result.stderr, "");
+    }
+    const schema = JSON.parse(results[5]?.stdout ?? "");
+    assert.equal(schema.command, "schema");
+    for (const fact of ["lookup", "schema", "found", "notFound"])
+      assert.ok(JSON.stringify(schema.data.manifest).includes(fact));
+    assert.match(results[6]?.stdout ?? "", /lookup/u);
+    assert.ok(results[6]?.stdout.includes(identity.commandName));
+    assert.equal(
+      results[7]?.stdout,
+      `${identity.commandName} ${identity.version}\n`,
+    );
+  },
+};
+
+export default journey;

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/test/integration/command.test.ts

@@ -5,79 +5,138 @@ import { describe, expect, it } from "vitest";
 import { cliCommandIdentity } from "../../src/cli-command-identity.ts";
 import { runCli, type CliRuntime } from "../../src/main.ts";
 
-const require = createRequire(import.meta.url);
-const packageManifest = require("../../package.json") as unknown;
-const identity = cliCommandIdentity(packageManifest);
+const identity = cliCommandIdentity(
+  createRequire(import.meta.url)("../../package.json"),
+);
 
-function testRuntime(args: readonly string[]): {
-  readonly runtime: CliRuntime;
-  readonly stdout: () => string;
-  readonly stderr: () => string;
-} {
+function testRuntime(args: readonly string[]) {
   let stdout = "";
   let stderr = "";
-  return {
-    runtime: {
-      argv: ["node", identity.commandName, ...args],
-      streams: {
-        stdin: {},
-        stdout: { write: (chunk) => (stdout += chunk) },
-        stderr: { write: (chunk) => (stderr += chunk) },
-      },
-      cwd: "/workspace",
-      env: { MODE: "test" },
-      tty: { stdin: false, stdout: false, stderr: false },
-      identity,
+  const runtime: CliRuntime = {
+    argv: ["node", identity.commandName, ...args],
+    identity,
+    write: ({ destination, chunk }) => {
+      if (destination === "stdout") stdout += chunk;
+      else stderr += chunk;
     },
-    stdout: () => stdout,
-    stderr: () => stderr,
   };
+  return { runtime, stdout: () => stdout, stderr: () => stderr };
 }
 
-describe("CLI command control", () => {
-  it("parses greet and writes business output to the injected stream", async () => {
-    const output = testRuntime(["greet", "  Ada Lovelace  "]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toBe("Hello, Ada Lovelace\n");
+describe("CLI 契约", () => {
+  it("查询成功默认返回结构化数据，也支持中文文本", async () => {
+    const output = testRuntime(["lookup", "ada"]);
+    expect(await runCli(output.runtime)).toBe(0);
+    expect(JSON.parse(output.stdout())).toEqual({
+      schemaVersion: "1",
+      command: "lookup",
+      kind: "data",
+      variant: "found",
+      data: { name: "ada", title: "Ada Lovelace" },
+    });
     expect(output.stderr()).toBe("");
+    const human = testRuntime(["lookup", "ada", "--output-format", "text"]);
+    expect(await runCli(human.runtime)).toBe(0);
+    expect(human.stdout()).toContain("找到记录");
+    expect(human.stdout()).toContain("Ada Lovelace");
   });
 
-  it("renders the version derived from the package manifest", async () => {
-    const output = testRuntime(["--version"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toBe(`${identity.version}\n`);
-    expect(output.stderr()).toBe("");
-  });
-
-  it("renders Commander help without exiting the process", async () => {
-    const output = testRuntime(["--help"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toContain(
-      `Usage: ${identity.commandName} [options] [command]`,
-    );
-    expect(output.stdout()).toContain("greet <name>");
-    expect(output.stderr()).toBe("");
+  it("未找到记录是已声明失败，非法名称是用法错误", async () => {
+    const missing = testRuntime(["lookup", "missing"]);
+    expect(await runCli(missing.runtime)).toBe(1);
+    expect(missing.stdout()).toBe("");
+    expect(JSON.parse(missing.stderr())).toMatchObject({
+      kind: "failure",
+      variant: "notFound",
+      data: { name: "missing" },
+    });
+    for (const args of [["lookup"], ["lookup", "   "]]) {
+      const invalid = testRuntime([...args, "--output-format", "text"]);
+      expect(await runCli(invalid.runtime)).toBe(2);
+      expect(invalid.stdout()).toBe("");
+      expect(JSON.parse(invalid.stderr())).toMatchObject({
+        kind: "usageFailure",
+      });
+    }
   });
 
-  it("reports missing arguments as Commander usage errors", async () => {
-    const output = testRuntime(["greet"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(1);
-    expect(output.stdout()).toBe("");
-    expect(output.stderr()).toContain(
-      "error: missing required argument 'name'",
+  it("帮助和版本使用 manifest 身份，schema 导出完整契约", async () => {
+    const version = testRuntime(["--version"]);
+    expect(await runCli(version.runtime)).toBe(0);
+    expect(version.stdout()).toBe(
+      `${identity.commandName} ${identity.version}\n`,
     );
-    expect(output.stderr()).toContain(`Usage: ${identity.commandName} greet`);
+    const help = testRuntime(["--help"]);
+    expect(await runCli(help.runtime)).toBe(0);
+    expect(help.stdout()).toContain(identity.commandName);
+    expect(help.stdout()).toContain("lookup");
+    expect(help.stdout()).toContain("schema");
+    const schema = testRuntime(["schema"]);
+    expect(await runCli(schema.runtime)).toBe(0);
+    const humanSchema = testRuntime(["schema", "--output-format", "text"]);
+    expect(await runCli(humanSchema.runtime)).toBe(0);
+    expect(humanSchema.stdout()).toContain("CLI 契约");
+    expect(humanSchema.stdout()).toContain('"commands"');
+    const manifest = JSON.parse(schema.stdout()).data.manifest;
+    expect(manifest).toMatchObject({
+      commands: {
+        lookup: {
+          input: {
+            inputSchema: {
+              properties: { name: { pattern: "^[a-z]+$" } },
+              required: ["name"],
+            },
+          },
+          success: { variants: { found: { exitCode: 0 } } },
+          failures: { notFound: { exitCode: 1 } },
+        },
+        schema: { success: { variants: { exported: { exitCode: 0 } } } },
+      },
+      controls: {
+        output: {
+          defaultFormat: "structured",
+          formats: ["structured", "text"],
+        },
+      },
+      usageFailure: { exitCode: 2 },
+    });
   });
 
-  it("adapts business validation into a testable command error", async () => {
-    const output = testRuntime(["greet", "   "]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(1);
-    expect(output.stdout()).toBe("");
-    expect(output.stderr()).toContain("error: Name must not be empty");
+  it("等待输出完成，仅 stdout EPIPE 安静成功", async () => {
+    const output = testRuntime(["lookup", "ada"]);
+    expect(
+      await runCli({
+        ...output.runtime,
+        write: async () => {
+          throw Object.assign(new Error("pipe"), { code: "EPIPE" });
+        },
+      }),
+    ).toBe(0);
+    expect(
+      await runCli({
+        ...output.runtime,
+        write: async () => {
+          throw new Error("disk");
+        },
+      }),
+    ).toBe(70);
+    const failure = testRuntime(["lookup", "missing"]);
+    expect(
+      await runCli({
+        ...failure.runtime,
+        write: async () => {
+          throw Object.assign(new Error("pipe"), { code: "EPIPE" });
+        },
+      }),
+    ).toBe(70);
+    const argv = ["node", identity.commandName];
+    Object.defineProperty(argv, "slice", {
+      value() {
+        throw new Error("内部细节");
+      },
+    });
+    expect(await runCli({ ...output.runtime, argv })).toBe(70);
+    expect(output.stderr()).toContain("命令执行失败");
+    expect(output.stderr()).not.toContain("内部细节");
   });
 });

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -21,6 +21,8 @@ overrides:
   "vue>typescript": "-"
 
 catalog:
+  "@ykdz/cli-contract": 0.2.1
+  "@valibot/to-json-schema": ^1.8.0
   "@devcontainers/cli": 0.89.0
   "@hono/node-server": ^2.0.12
   "@playwright/test": ^1.62.1
@@ -31,7 +33,6 @@ catalog:
   "@vikejs/hono": ^0.2.1
   "@vue/devtools-api": ^8.1.5
   "@vue/tsconfig": ^0.9.1
-  commander: ^15.0.0
   drizzle-kit: 1.0.0-rc.5-ab785fc
   drizzle-orm: 1.0.0-rc.5-ab785fc
   execa: ^10.0.1

package/node_modules/@ykdz/template-core/dist/project-blueprint.d.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 /**
  * The durable, preset-agnostic topology used by local template follow-up
  * operations. Preset provenance deliberately belongs in Generation Record.
@@ -40,6 +41,20 @@ export type BlueprintValidationResult = {
     readonly ok: false;
     readonly issues: readonly BlueprintValidationIssue[];
 };
+declare function packageDefinitionMessage(issue: v.BaseIssue<unknown>): string;
+export declare const projectBlueprintSchema: v.StrictObjectSchema<{
+    readonly schemaVersion: v.LiteralSchema<3, (issue: v.LiteralIssue) => string>;
+    readonly packages: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.StringSchema<"Package name must be a string">;
+        readonly path: v.StringSchema<"Package Path must be a string">;
+        readonly role: v.PicklistSchema<readonly ["cli-tool", "runtime-service", "shared-library", "native-package"], "Package Role must be cli-tool, runtime-service, shared-library, or native-package">;
+        readonly packageDefinitionId: v.StringSchema<"Package Definition ID must use the package-<sha256> format">;
+    }, typeof packageDefinitionMessage>, "Package Definitions must be an array">;
+    readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly consumerPackagePath: v.StringSchema<"Package Link Intent consumer Package Path must be a string">;
+        readonly providerPackagePath: v.StringSchema<"Package Link Intent provider Package Path must be a string">;
+    }, (issue: v.StrictObjectIssue) => "Package Link Intent must be an object" | "Unknown Blueprint v3 field">, "Package Link Intents must be an array">, undefined>;
+}, (issue: v.StrictObjectIssue) => "Local Template Metadata must be an object" | "Unknown Blueprint v3 field">;
 /** Canonical npm package-name predicate shared by Blueprint and input preparation. */
 export declare function isValidNewNpmPackageName(value: string): boolean;
 export type NewPackagePathValidation = {

package/node_modules/@ykdz/template-core/dist/project-blueprint.js

@@ -42,7 +42,7 @@ const packageLinkIntentSchema = v.strictObject({
 }, (issue) => issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
     ? unknownBlueprintField
     : "Package Link Intent must be an object");
-const projectBlueprintSchema = v.strictObject({
+export const projectBlueprintSchema = v.strictObject({
     schemaVersion: v.literal(3, (issue) => `Unsupported Local Template Metadata schema version ${String(issue.input)}; expected 3`),
     packages: v.array(packageDefinitionSchema, "Package Definitions must be an array"),
     packageLinkIntents: v.optional(v.array(packageLinkIntentSchema, "Package Link Intents must be an array")),