@ternent/seal 0.3.10

package/dist/cli.js

@@ -0,0 +1,441 @@
+import { stat, readFile, readdir, mkdir, writeFile } from "node:fs/promises";
+import { resolve, basename, join, relative, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSealHash, createSealProof, createSealPublicKeyArtifact, parseSealProofJson, verifySealProofAgainstBytes } from "./proof.js";
+import { SEAL_MANIFEST_VERSION, SEAL_MANIFEST_TYPE, stringifySealManifest, parseSealManifestJson } from "./manifest.js";
+import { createSealMnemonicIdentity, createSealIdentity, exportIdentityJson } from "./crypto.js";
+import { createSealArtifact, parseSealArtifactJson, verifySealArtifact } from "./artifact.js";
+import { parseIdentity } from "@ternent/identity";
+import { EXIT_SUCCESS, EXIT_HASH_MISMATCH, EXIT_SIGNATURE_INVALID, SealCliError, EXIT_FAILURE, EXIT_INVALID_PROOF, EXIT_KEY_CONFIG, getExitCode } from "./errors.js";
+import "./chunks/utils.es-ad8f1dc4.js";
+import "@ternent/armour";
+function normalizeRelativePath(value) {
+  return value.split("\\").join("/");
+}
+async function collectFiles(rootPath, currentPath, files) {
+  const entries = await readdir(currentPath, { withFileTypes: true });
+  const sorted = entries.filter((entry) => entry.name !== ".DS_Store").sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sorted) {
+    const entryPath = join(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      await collectFiles(rootPath, entryPath, files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const bytes = await readFile(entryPath);
+    const relativePath = normalizeRelativePath(relative(rootPath, entryPath));
+    files[relativePath] = await createSealHash(bytes);
+  }
+}
+async function createManifestArtifact(inputPath) {
+  const resolvedInput = resolve(inputPath);
+  const inputStat = await stat(resolvedInput);
+  const root = basename(resolvedInput);
+  const files = {};
+  if (inputStat.isDirectory()) {
+    await collectFiles(resolvedInput, resolvedInput, files);
+  } else if (inputStat.isFile()) {
+    const bytes = await readFile(resolvedInput);
+    files[root] = await createSealHash(bytes);
+  } else {
+    throw new Error("Manifest input must be a file or directory.");
+  }
+  const manifest = {
+    version: SEAL_MANIFEST_VERSION,
+    type: SEAL_MANIFEST_TYPE,
+    root,
+    files: Object.fromEntries(
+      Object.entries(files).sort(([left], [right]) => left.localeCompare(right))
+    )
+  };
+  return {
+    manifest,
+    content: `${stringifySealManifest(manifest)}
+`
+  };
+}
+function formatMnemonicBackup(input) {
+  const lines = ["Seal seed phrase backup", "", "Mnemonic:", input.mnemonic];
+  if (String(input.passphrase || "").trim()) {
+    lines.push("", "Passphrase:", String(input.passphrase));
+  }
+  lines.push(
+    "",
+    "Store this file securely. Anyone with this recovery material can recreate the signer."
+  );
+  return `${lines.join("\n")}
+`;
+}
+async function createIdentityArtifact(input = {}) {
+  const useMnemonic = Boolean(input.withMnemonic) || input.words === 12 || input.words === 24 || Boolean(input.passphrase);
+  const created = useMnemonic ? await createSealMnemonicIdentity({
+    words: input.words,
+    passphrase: input.passphrase
+  }) : {
+    identity: await createSealIdentity(),
+    mnemonic: null
+  };
+  return {
+    identity: created.identity,
+    content: exportIdentityJson(created.identity),
+    mnemonic: created.mnemonic,
+    mnemonicContent: created.mnemonic ? formatMnemonicBackup({
+      mnemonic: created.mnemonic,
+      passphrase: input.passphrase
+    }) : null
+  };
+}
+async function createProofArtifact(params) {
+  const bytes = await readFile(params.inputPath);
+  const raw = new TextDecoder().decode(bytes);
+  const parsedManifest = parseSealManifestJson(raw);
+  const proof = await createSealProof({
+    signer: {
+      identity: params.identity
+    },
+    subject: {
+      kind: parsedManifest.ok ? "manifest" : "file",
+      path: basename(params.inputPath),
+      hash: await createSealHash(bytes)
+    }
+  });
+  return {
+    proof,
+    content: `${JSON.stringify(proof, null, 2)}
+`
+  };
+}
+async function createRecipientArtifact(params) {
+  const bytes = await readFile(params.inputPath);
+  const artifact = await createSealArtifact({
+    signer: {
+      identity: params.identity
+    },
+    subjectPath: basename(params.inputPath),
+    payload: bytes,
+    recipients: params.recipients
+  });
+  return {
+    artifact,
+    content: `${JSON.stringify(artifact, null, 2)}
+`
+  };
+}
+async function createPublicKeyArtifact(params) {
+  return createSealPublicKeyArtifact(params);
+}
+async function verifyProofArtifact(params) {
+  const rawProof = await readFile(params.proofPath, "utf8");
+  const parsed = parseSealProofJson(rawProof);
+  if (!parsed.ok || !parsed.proof) {
+    throw new Error(parsed.errors.join(" "));
+  }
+  const subjectBytes = await readFile(params.inputPath);
+  const result = await verifySealProofAgainstBytes(parsed.proof, subjectBytes);
+  return {
+    proof: parsed.proof,
+    result
+  };
+}
+async function verifyArtifactProof(params) {
+  const rawArtifact = await readFile(params.artifactPath, "utf8");
+  const parsed = parseSealArtifactJson(rawArtifact);
+  if (!parsed.ok || !parsed.artifact) {
+    throw new Error(parsed.errors.join(" "));
+  }
+  return {
+    artifact: parsed.artifact,
+    result: await verifySealArtifact(parsed.artifact)
+  };
+}
+async function resolveSealIdentityFromEnv(env) {
+  const identityJson = String(env.SEAL_IDENTITY || "").trim();
+  if (identityJson) {
+    return parseIdentity(identityJson);
+  }
+  const identityFile = String(env.SEAL_IDENTITY_FILE || "").trim();
+  if (identityFile) {
+    return parseIdentity(await readFile(identityFile, "utf8"));
+  }
+  throw new Error("Missing SEAL_IDENTITY or SEAL_IDENTITY_FILE environment variable.");
+}
+function parseArgs(argv) {
+  const result = { _: [], flags: {} };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) {
+      result._.push(arg);
+      continue;
+    }
+    const [rawKey, inlineValue] = arg.slice(2).split("=");
+    const key = rawKey.trim();
+    const next = argv[index + 1];
+    const hasNextValue = inlineValue === void 0 && next && !next.startsWith("--");
+    const value = inlineValue ?? (hasNextValue ? next : void 0);
+    if (hasNextValue) {
+      index += 1;
+    }
+    if (value === void 0) {
+      result.flags[key] = true;
+      continue;
+    }
+    const existing = result.flags[key];
+    if (existing === void 0) {
+      result.flags[key] = value;
+      continue;
+    }
+    if (Array.isArray(existing)) {
+      existing.push(value);
+      result.flags[key] = existing;
+      continue;
+    }
+    result.flags[key] = [String(existing), value];
+  }
+  return result;
+}
+function getFlag(flags, key) {
+  const value = flags[key];
+  if (Array.isArray(value)) {
+    return value[value.length - 1];
+  }
+  return typeof value === "string" ? value : void 0;
+}
+function getFlags(flags, key) {
+  const value = flags[key];
+  if (Array.isArray(value)) {
+    return value.map(String);
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  return [];
+}
+function hasFlag(flags, key) {
+  return flags[key] === true;
+}
+function requireFlag(flags, key) {
+  const value = getFlag(flags, key);
+  if (!value) {
+    throw new SealCliError(`Missing --${key}`, EXIT_FAILURE);
+  }
+  return value;
+}
+function parseMnemonicWordCount(flags) {
+  const words = getFlag(flags, "words");
+  if (!words) {
+    return void 0;
+  }
+  if (words === "12" || words === "24") {
+    return Number(words);
+  }
+  throw new SealCliError("Mnemonic word count must be 12 or 24.", EXIT_FAILURE);
+}
+async function writeOutputFile(filePath, content) {
+  const resolvedPath = resolve(filePath);
+  await mkdir(dirname(resolvedPath), { recursive: true });
+  await writeFile(resolvedPath, content, "utf8");
+}
+function outputResult(writer, json, quiet, value) {
+  if (quiet) {
+    return;
+  }
+  if (typeof value === "string") {
+    writer.stdout(`${value}
+`);
+    return;
+  }
+  if (json) {
+    writer.stdout(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  writer.stdout(`${JSON.stringify(value, null, 2)}
+`);
+}
+function outputError(writer, json, error) {
+  const exitCode = getExitCode(error);
+  const message = error instanceof Error ? error.message : String(error);
+  if (json) {
+    writer.stderr(`${JSON.stringify({ error: message, exitCode }, null, 2)}
+`);
+  } else {
+    writer.stderr(`${message}
+`);
+  }
+  return exitCode;
+}
+async function runCli(argv, params = {}) {
+  const parsed = parseArgs(argv);
+  const env = params.env ?? process.env;
+  const writer = params.writer ?? {
+    stdout: (value) => process.stdout.write(value),
+    stderr: (value) => process.stderr.write(value)
+  };
+  const json = hasFlag(parsed.flags, "json");
+  const quiet = hasFlag(parsed.flags, "quiet");
+  try {
+    const [command, subcommand] = parsed._;
+    if (command === "identity" && subcommand === "create") {
+      const mnemonicOutPath = getFlag(parsed.flags, "mnemonic-out");
+      const artifact = await createIdentityArtifact({
+        withMnemonic: Boolean(mnemonicOutPath),
+        words: parseMnemonicWordCount(parsed.flags),
+        passphrase: getFlag(parsed.flags, "passphrase")
+      });
+      const outPath = getFlag(parsed.flags, "out");
+      if (outPath) {
+        await writeOutputFile(outPath, artifact.content);
+      }
+      if (mnemonicOutPath) {
+        await writeOutputFile(mnemonicOutPath, artifact.mnemonicContent || "");
+      }
+      if (outPath) {
+        outputResult(
+          writer,
+          json,
+          quiet,
+          json ? artifact.mnemonic ? {
+            identity: artifact.identity,
+            mnemonic: artifact.mnemonic,
+            mnemonicFile: mnemonicOutPath || null
+          } : artifact.identity : outPath
+        );
+      } else {
+        outputResult(
+          writer,
+          true,
+          quiet,
+          artifact.mnemonic ? {
+            identity: artifact.identity,
+            mnemonic: artifact.mnemonic,
+            mnemonicFile: mnemonicOutPath || null
+          } : artifact.identity
+        );
+      }
+      return EXIT_SUCCESS;
+    }
+    if (command === "manifest" && subcommand === "create") {
+      const artifact = await createManifestArtifact(requireFlag(parsed.flags, "input"));
+      const outPath = getFlag(parsed.flags, "out");
+      if (outPath) {
+        await writeOutputFile(outPath, artifact.content);
+        outputResult(writer, json, quiet, json ? artifact.manifest : outPath);
+      } else {
+        outputResult(writer, true, quiet, artifact.manifest);
+      }
+      return EXIT_SUCCESS;
+    }
+    if (command === "sign") {
+      const identity = await resolveSealIdentityFromEnv(env);
+      const recipients = getFlags(parsed.flags, "recipient");
+      const inputPath = requireFlag(parsed.flags, "input");
+      const outPath = getFlag(parsed.flags, "out");
+      if (recipients.length > 0) {
+        const artifact = await createRecipientArtifact({
+          inputPath,
+          identity,
+          recipients
+        });
+        if (outPath) {
+          await writeOutputFile(outPath, artifact.content);
+          outputResult(writer, json, quiet, json ? artifact.artifact : outPath);
+        } else {
+          outputResult(writer, true, quiet, artifact.artifact);
+        }
+      } else {
+        const artifact = await createProofArtifact({
+          inputPath,
+          identity
+        });
+        if (outPath) {
+          await writeOutputFile(outPath, artifact.content);
+          outputResult(writer, json, quiet, json ? artifact.proof : outPath);
+        } else {
+          outputResult(writer, true, quiet, artifact.proof);
+        }
+      }
+      return EXIT_SUCCESS;
+    }
+    if (command === "verify") {
+      const artifactPath = getFlag(parsed.flags, "artifact");
+      if (artifactPath) {
+        const { result: result2 } = await verifyArtifactProof({ artifactPath });
+        outputResult(
+          writer,
+          json,
+          quiet,
+          json ? result2 : [
+            `valid=${result2.valid}`,
+            `hashMatch=${result2.hashMatch}`,
+            `signatureValid=${result2.signatureValid}`,
+            `encrypted=${result2.encrypted}`,
+            `payloadScheme=${result2.payloadScheme}`,
+            `payloadMode=${result2.payloadMode}`,
+            `keyId=${result2.keyId}`,
+            `algorithm=${result2.algorithm}`,
+            `subjectHash=${result2.subjectHash}`
+          ].join("\n")
+        );
+        if (!result2.hashMatch) {
+          return EXIT_HASH_MISMATCH;
+        }
+        if (!result2.signatureValid) {
+          return EXIT_SIGNATURE_INVALID;
+        }
+        return EXIT_SUCCESS;
+      }
+      const proofPath = requireFlag(parsed.flags, "proof");
+      const inputPath = requireFlag(parsed.flags, "input");
+      const { result } = await verifyProofArtifact({ proofPath, inputPath });
+      outputResult(
+        writer,
+        json,
+        quiet,
+        json ? result : [
+          `valid=${result.valid}`,
+          `hashMatch=${result.hashMatch}`,
+          `signatureValid=${result.signatureValid}`,
+          `keyId=${result.keyId}`,
+          `algorithm=${result.algorithm}`,
+          `subjectHash=${result.subjectHash}`
+        ].join("\n")
+      );
+      if (!result.hashMatch) {
+        return EXIT_HASH_MISMATCH;
+      }
+      if (!result.signatureValid) {
+        return EXIT_SIGNATURE_INVALID;
+      }
+      return EXIT_SUCCESS;
+    }
+    if (command === "public-key") {
+      const artifact = await createPublicKeyArtifact({
+        identity: await resolveSealIdentityFromEnv(env)
+      });
+      outputResult(writer, true, quiet, artifact);
+      return EXIT_SUCCESS;
+    }
+    throw new SealCliError(
+      "Usage: seal identity create [--out <path>] [--words 12|24] [--passphrase <value>] [--mnemonic-out <path>] [--json] [--quiet]\n       seal manifest create --input <path> [--out <path>] [--json] [--quiet]\n       seal sign --input <path> [--recipient <age...>] [--out <path>] [--json] [--quiet]\n       seal verify --proof <proof.json> --input <path> [--json] [--quiet]\n       seal verify --artifact <artifact.json> [--json] [--quiet]\n       seal public-key [--json] [--quiet]",
+      EXIT_FAILURE
+    );
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Proof")) {
+      return outputError(writer, json, new SealCliError(error.message, EXIT_INVALID_PROOF));
+    }
+    if (error instanceof Error && (error.message.includes("public key") || error.message.includes("SEAL_IDENTITY") || error.message.includes("identity"))) {
+      return outputError(writer, json, new SealCliError(error.message, EXIT_KEY_CONFIG));
+    }
+    return outputError(writer, json, error);
+  }
+}
+const isDirectRun = typeof process !== "undefined" && process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+if (isDirectRun) {
+  runCli(process.argv.slice(2)).then((exitCode) => {
+    process.exitCode = exitCode;
+  });
+}
+export { runCli };
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sources":["../src/commands/manifest.ts","../src/commands/identity.ts","../src/commands/sign.ts","../src/commands/publicKey.ts","../src/commands/verify.ts","../src/node.ts","../src/cli.ts"],"sourcesContent":["import { readdir, readFile, stat } from \"node:fs/promises\";\nimport { basename, join, relative, resolve } from \"node:path\";\nimport { createSealHash } from \"../proof\";\nimport {\n  SEAL_MANIFEST_TYPE,\n  SEAL_MANIFEST_VERSION,\n  stringifySealManifest,\n  type SealManifestV1,\n} from \"../manifest\";\n\nfunction normalizeRelativePath(value: string): string {\n  return value.split(\"\\\\\").join(\"/\");\n}\n\nasync function collectFiles(\n  rootPath: string,\n  currentPath: string,\n  files: Record<string, SealManifestV1[\"files\"][string]>,\n): Promise<void> {\n  const entries = await readdir(currentPath, { withFileTypes: true });\n  const sorted = entries\n    .filter((entry) => entry.name !== \".DS_Store\")\n    .sort((a, b) => a.name.localeCompare(b.name));\n\n  for (const entry of sorted) {\n    const entryPath = join(currentPath, entry.name);\n    if (entry.isDirectory()) {\n      await collectFiles(rootPath, entryPath, files);\n      continue;\n    }\n    if (!entry.isFile()) {\n      continue;\n    }\n    const bytes = await readFile(entryPath);\n    const relativePath = normalizeRelativePath(relative(rootPath, entryPath));\n    files[relativePath] = await createSealHash(bytes);\n  }\n}\n\nexport async function createManifestArtifact(inputPath: string): Promise<{\n  manifest: SealManifestV1;\n  content: string;\n}> {\n  const resolvedInput = resolve(inputPath);\n  const inputStat = await stat(resolvedInput);\n  const root = basename(resolvedInput);\n  const files: SealManifestV1[\"files\"] = {};\n\n  if (inputStat.isDirectory()) {\n    await collectFiles(resolvedInput, resolvedInput, files);\n  } else if (inputStat.isFile()) {\n    const bytes = await readFile(resolvedInput);\n    files[root] = await createSealHash(bytes);\n  } else {\n    throw new Error(\"Manifest input must be a file or directory.\");\n  }\n\n  const manifest: SealManifestV1 = {\n    version: SEAL_MANIFEST_VERSION,\n    type: SEAL_MANIFEST_TYPE,\n    root,\n    files: Object.fromEntries(\n      Object.entries(files).sort(([left], [right]) => left.localeCompare(right)),\n    ),\n  };\n\n  return {\n    manifest,\n    content: `${stringifySealManifest(manifest)}\\n`,\n  };\n}\n","import { createSealIdentity, createSealMnemonicIdentity, exportIdentityJson } from \"../crypto\";\n\nfunction formatMnemonicBackup(input: { mnemonic: string; passphrase?: string }): string {\n  const lines = [\"Seal seed phrase backup\", \"\", \"Mnemonic:\", input.mnemonic];\n  if (String(input.passphrase || \"\").trim()) {\n    lines.push(\"\", \"Passphrase:\", String(input.passphrase));\n  }\n  lines.push(\n    \"\",\n    \"Store this file securely. Anyone with this recovery material can recreate the signer.\",\n  );\n  return `${lines.join(\"\\n\")}\\n`;\n}\n\nexport async function createIdentityArtifact(\n  input: {\n    withMnemonic?: boolean;\n    words?: 12 | 24;\n    passphrase?: string;\n  } = {},\n): Promise<{\n  identity: import(\"@ternent/identity\").SerializedIdentity;\n  content: string;\n  mnemonic: string | null;\n  mnemonicContent: string | null;\n}> {\n  const useMnemonic =\n    Boolean(input.withMnemonic) ||\n    input.words === 12 ||\n    input.words === 24 ||\n    Boolean(input.passphrase);\n  const created = useMnemonic\n    ? await createSealMnemonicIdentity({\n        words: input.words,\n        passphrase: input.passphrase,\n      })\n    : {\n        identity: await createSealIdentity(),\n        mnemonic: null,\n      };\n  return {\n    identity: created.identity,\n    content: exportIdentityJson(created.identity),\n    mnemonic: created.mnemonic,\n    mnemonicContent: created.mnemonic\n      ? formatMnemonicBackup({\n          mnemonic: created.mnemonic,\n          passphrase: input.passphrase,\n        })\n      : null,\n  };\n}\n","import { basename } from \"node:path\";\nimport { readFile } from \"node:fs/promises\";\nimport { createSealArtifact, type SealArtifactV1 } from \"../artifact\";\nimport { parseSealManifestJson } from \"../manifest\";\nimport { createSealProof, createSealHash, type SealProofV1 } from \"../proof\";\n\nexport async function createProofArtifact(params: {\n  inputPath: string;\n  identity: import(\"@ternent/identity\").SerializedIdentity;\n}): Promise<{\n  proof: SealProofV1;\n  content: string;\n}> {\n  const bytes = await readFile(params.inputPath);\n  const raw = new TextDecoder().decode(bytes);\n  const parsedManifest = parseSealManifestJson(raw);\n  const proof = await createSealProof({\n    signer: {\n      identity: params.identity,\n    },\n    subject: {\n      kind: parsedManifest.ok ? \"manifest\" : \"file\",\n      path: basename(params.inputPath),\n      hash: await createSealHash(bytes),\n    },\n  });\n\n  return {\n    proof,\n    content: `${JSON.stringify(proof, null, 2)}\\n`,\n  };\n}\n\nexport async function createRecipientArtifact(params: {\n  inputPath: string;\n  identity: import(\"@ternent/identity\").SerializedIdentity;\n  recipients: string[];\n}): Promise<{\n  artifact: SealArtifactV1;\n  content: string;\n}> {\n  const bytes = await readFile(params.inputPath);\n  const artifact = await createSealArtifact({\n    signer: {\n      identity: params.identity,\n    },\n    subjectPath: basename(params.inputPath),\n    payload: bytes,\n    recipients: params.recipients,\n  });\n\n  return {\n    artifact,\n    content: `${JSON.stringify(artifact, null, 2)}\\n`,\n  };\n}\n","import { createSealPublicKeyArtifact } from \"../proof\";\n\nexport async function createPublicKeyArtifact(params: {\n  identity: import(\"@ternent/identity\").SerializedIdentity;\n}) {\n  return createSealPublicKeyArtifact(params);\n}\n","import { readFile } from \"node:fs/promises\";\nimport {\n  parseSealArtifactJson,\n  verifySealArtifact,\n  type SealArtifactV1,\n  type VerifySealArtifactResult,\n} from \"../artifact\";\nimport { parseSealProofJson, verifySealProofAgainstBytes, type SealProofV1 } from \"../proof\";\n\nexport type VerifyArtifactResult = {\n  valid: boolean;\n  hashMatch: boolean;\n  signatureValid: boolean;\n  keyId: string;\n  algorithm: \"Ed25519\";\n  subjectHash: `sha256:${string}`;\n};\n\nexport async function verifyProofArtifact(params: {\n  proofPath: string;\n  inputPath: string;\n}): Promise<{\n  proof: SealProofV1;\n  result: VerifyArtifactResult;\n}> {\n  const rawProof = await readFile(params.proofPath, \"utf8\");\n  const parsed = parseSealProofJson(rawProof);\n  if (!parsed.ok || !parsed.proof) {\n    throw new Error(parsed.errors.join(\" \"));\n  }\n\n  const subjectBytes = await readFile(params.inputPath);\n  const result = await verifySealProofAgainstBytes(parsed.proof, subjectBytes);\n  return {\n    proof: parsed.proof,\n    result,\n  };\n}\n\nexport async function verifyArtifactProof(params: { artifactPath: string }): Promise<{\n  artifact: SealArtifactV1;\n  result: VerifySealArtifactResult;\n}> {\n  const rawArtifact = await readFile(params.artifactPath, \"utf8\");\n  const parsed = parseSealArtifactJson(rawArtifact);\n  if (!parsed.ok || !parsed.artifact) {\n    throw new Error(parsed.errors.join(\" \"));\n  }\n\n  return {\n    artifact: parsed.artifact,\n    result: await verifySealArtifact(parsed.artifact),\n  };\n}\n","import { readFile } from \"node:fs/promises\";\nimport { parseIdentity, type SerializedIdentity } from \"@ternent/identity\";\n\nexport async function resolveSealIdentityFromEnv(\n  env: Record<string, string | undefined>,\n): Promise<SerializedIdentity> {\n  const identityJson = String(env.SEAL_IDENTITY || \"\").trim();\n  if (identityJson) {\n    return parseIdentity(identityJson);\n  }\n\n  const identityFile = String(env.SEAL_IDENTITY_FILE || \"\").trim();\n  if (identityFile) {\n    return parseIdentity(await readFile(identityFile, \"utf8\"));\n  }\n\n  throw new Error(\"Missing SEAL_IDENTITY or SEAL_IDENTITY_FILE environment variable.\");\n}\n","import { mkdir, writeFile } from \"node:fs/promises\";\nimport { dirname, resolve } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { createManifestArtifact } from \"./commands/manifest\";\nimport { createIdentityArtifact } from \"./commands/identity\";\nimport { createProofArtifact, createRecipientArtifact } from \"./commands/sign\";\nimport { createPublicKeyArtifact } from \"./commands/publicKey\";\nimport { verifyArtifactProof, verifyProofArtifact } from \"./commands/verify\";\nimport { resolveSealIdentityFromEnv } from \"./node\";\nimport {\n  EXIT_FAILURE,\n  EXIT_HASH_MISMATCH,\n  EXIT_INVALID_PROOF,\n  EXIT_KEY_CONFIG,\n  EXIT_SIGNATURE_INVALID,\n  EXIT_SUCCESS,\n  SealCliError,\n  getExitCode,\n} from \"./errors\";\n\ntype ProcessEnvLike = Record<string, string | undefined>;\n\ndeclare const process: {\n  argv: string[];\n  env: ProcessEnvLike;\n  stdout: { write: (value: string) => void };\n  stderr: { write: (value: string) => void };\n  exitCode?: number;\n};\n\ntype ParsedArgs = {\n  _: string[];\n  flags: Record<string, string | boolean | string[]>;\n};\n\ntype OutputWriter = {\n  stdout: (value: string) => void;\n  stderr: (value: string) => void;\n};\n\nfunction parseArgs(argv: string[]): ParsedArgs {\n  const result: ParsedArgs = { _: [], flags: {} };\n  for (let index = 0; index < argv.length; index += 1) {\n    const arg = argv[index];\n    if (!arg.startsWith(\"--\")) {\n      result._.push(arg);\n      continue;\n    }\n\n    const [rawKey, inlineValue] = arg.slice(2).split(\"=\");\n    const key = rawKey.trim();\n    const next = argv[index + 1];\n    const hasNextValue = inlineValue === undefined && next && !next.startsWith(\"--\");\n    const value = inlineValue ?? (hasNextValue ? next : undefined);\n\n    if (hasNextValue) {\n      index += 1;\n    }\n\n    if (value === undefined) {\n      result.flags[key] = true;\n      continue;\n    }\n\n    const existing = result.flags[key];\n    if (existing === undefined) {\n      result.flags[key] = value;\n      continue;\n    }\n\n    if (Array.isArray(existing)) {\n      existing.push(value);\n      result.flags[key] = existing;\n      continue;\n    }\n\n    result.flags[key] = [String(existing), value];\n  }\n\n  return result;\n}\n\nfunction getFlag(flags: ParsedArgs[\"flags\"], key: string): string | undefined {\n  const value = flags[key];\n  if (Array.isArray(value)) {\n    return value[value.length - 1];\n  }\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction getFlags(flags: ParsedArgs[\"flags\"], key: string): string[] {\n  const value = flags[key];\n  if (Array.isArray(value)) {\n    return value.map(String);\n  }\n  if (typeof value === \"string\") {\n    return [value];\n  }\n  return [];\n}\n\nfunction hasFlag(flags: ParsedArgs[\"flags\"], key: string): boolean {\n  return flags[key] === true;\n}\n\nfunction requireFlag(flags: ParsedArgs[\"flags\"], key: string): string {\n  const value = getFlag(flags, key);\n  if (!value) {\n    throw new SealCliError(`Missing --${key}`, EXIT_FAILURE);\n  }\n  return value;\n}\n\nfunction parseMnemonicWordCount(flags: ParsedArgs[\"flags\"]): 12 | 24 | undefined {\n  const words = getFlag(flags, \"words\");\n  if (!words) {\n    return undefined;\n  }\n  if (words === \"12\" || words === \"24\") {\n    return Number(words) as 12 | 24;\n  }\n  throw new SealCliError(\"Mnemonic word count must be 12 or 24.\", EXIT_FAILURE);\n}\n\nasync function writeOutputFile(filePath: string, content: string): Promise<void> {\n  const resolvedPath = resolve(filePath);\n  await mkdir(dirname(resolvedPath), { recursive: true });\n  await writeFile(resolvedPath, content, \"utf8\");\n}\n\nfunction outputResult(writer: OutputWriter, json: boolean, quiet: boolean, value: unknown): void {\n  if (quiet) {\n    return;\n  }\n\n  if (typeof value === \"string\") {\n    writer.stdout(`${value}\\n`);\n    return;\n  }\n\n  if (json) {\n    writer.stdout(`${JSON.stringify(value, null, 2)}\\n`);\n    return;\n  }\n\n  writer.stdout(`${JSON.stringify(value, null, 2)}\\n`);\n}\n\nfunction outputError(writer: OutputWriter, json: boolean, error: unknown): number {\n  const exitCode = getExitCode(error);\n  const message = error instanceof Error ? error.message : String(error);\n  if (json) {\n    writer.stderr(`${JSON.stringify({ error: message, exitCode }, null, 2)}\\n`);\n  } else {\n    writer.stderr(`${message}\\n`);\n  }\n  return exitCode;\n}\n\nexport async function runCli(\n  argv: string[],\n  params: {\n    env?: ProcessEnvLike;\n    writer?: OutputWriter;\n  } = {},\n): Promise<number> {\n  const parsed = parseArgs(argv);\n  const env = params.env ?? process.env;\n  const writer: OutputWriter = params.writer ?? {\n    stdout: (value) => process.stdout.write(value),\n    stderr: (value) => process.stderr.write(value),\n  };\n  const json = hasFlag(parsed.flags, \"json\");\n  const quiet = hasFlag(parsed.flags, \"quiet\");\n\n  try {\n    const [command, subcommand] = parsed._;\n\n    if (command === \"identity\" && subcommand === \"create\") {\n      const mnemonicOutPath = getFlag(parsed.flags, \"mnemonic-out\");\n      const artifact = await createIdentityArtifact({\n        withMnemonic: Boolean(mnemonicOutPath),\n        words: parseMnemonicWordCount(parsed.flags),\n        passphrase: getFlag(parsed.flags, \"passphrase\"),\n      });\n      const outPath = getFlag(parsed.flags, \"out\");\n      if (outPath) {\n        await writeOutputFile(outPath, artifact.content);\n      }\n      if (mnemonicOutPath) {\n        await writeOutputFile(mnemonicOutPath, artifact.mnemonicContent || \"\");\n      }\n\n      if (outPath) {\n        outputResult(\n          writer,\n          json,\n          quiet,\n          json\n            ? artifact.mnemonic\n              ? {\n                  identity: artifact.identity,\n                  mnemonic: artifact.mnemonic,\n                  mnemonicFile: mnemonicOutPath || null,\n                }\n              : artifact.identity\n            : outPath,\n        );\n      } else {\n        outputResult(\n          writer,\n          true,\n          quiet,\n          artifact.mnemonic\n            ? {\n                identity: artifact.identity,\n                mnemonic: artifact.mnemonic,\n                mnemonicFile: mnemonicOutPath || null,\n              }\n            : artifact.identity,\n        );\n      }\n      return EXIT_SUCCESS;\n    }\n\n    if (command === \"manifest\" && subcommand === \"create\") {\n      const artifact = await createManifestArtifact(requireFlag(parsed.flags, \"input\"));\n      const outPath = getFlag(parsed.flags, \"out\");\n      if (outPath) {\n        await writeOutputFile(outPath, artifact.content);\n        outputResult(writer, json, quiet, json ? artifact.manifest : outPath);\n      } else {\n        outputResult(writer, true, quiet, artifact.manifest);\n      }\n      return EXIT_SUCCESS;\n    }\n\n    if (command === \"sign\") {\n      const identity = await resolveSealIdentityFromEnv(env);\n      const recipients = getFlags(parsed.flags, \"recipient\");\n      const inputPath = requireFlag(parsed.flags, \"input\");\n      const outPath = getFlag(parsed.flags, \"out\");\n      if (recipients.length > 0) {\n        const artifact = await createRecipientArtifact({\n          inputPath,\n          identity,\n          recipients,\n        });\n        if (outPath) {\n          await writeOutputFile(outPath, artifact.content);\n          outputResult(writer, json, quiet, json ? artifact.artifact : outPath);\n        } else {\n          outputResult(writer, true, quiet, artifact.artifact);\n        }\n      } else {\n        const artifact = await createProofArtifact({\n          inputPath,\n          identity,\n        });\n        if (outPath) {\n          await writeOutputFile(outPath, artifact.content);\n          outputResult(writer, json, quiet, json ? artifact.proof : outPath);\n        } else {\n          outputResult(writer, true, quiet, artifact.proof);\n        }\n      }\n      return EXIT_SUCCESS;\n    }\n\n    if (command === \"verify\") {\n      const artifactPath = getFlag(parsed.flags, \"artifact\");\n      if (artifactPath) {\n        const { result } = await verifyArtifactProof({ artifactPath });\n        outputResult(\n          writer,\n          json,\n          quiet,\n          json\n            ? result\n            : [\n                `valid=${result.valid}`,\n                `hashMatch=${result.hashMatch}`,\n                `signatureValid=${result.signatureValid}`,\n                `encrypted=${result.encrypted}`,\n                `payloadScheme=${result.payloadScheme}`,\n                `payloadMode=${result.payloadMode}`,\n                `keyId=${result.keyId}`,\n                `algorithm=${result.algorithm}`,\n                `subjectHash=${result.subjectHash}`,\n              ].join(\"\\n\"),\n        );\n\n        if (!result.hashMatch) {\n          return EXIT_HASH_MISMATCH;\n        }\n        if (!result.signatureValid) {\n          return EXIT_SIGNATURE_INVALID;\n        }\n        return EXIT_SUCCESS;\n      }\n\n      const proofPath = requireFlag(parsed.flags, \"proof\");\n      const inputPath = requireFlag(parsed.flags, \"input\");\n      const { result } = await verifyProofArtifact({ proofPath, inputPath });\n      outputResult(\n        writer,\n        json,\n        quiet,\n        json\n          ? result\n          : [\n              `valid=${result.valid}`,\n              `hashMatch=${result.hashMatch}`,\n              `signatureValid=${result.signatureValid}`,\n              `keyId=${result.keyId}`,\n              `algorithm=${result.algorithm}`,\n              `subjectHash=${result.subjectHash}`,\n            ].join(\"\\n\"),\n      );\n\n      if (!result.hashMatch) {\n        return EXIT_HASH_MISMATCH;\n      }\n      if (!result.signatureValid) {\n        return EXIT_SIGNATURE_INVALID;\n      }\n      return EXIT_SUCCESS;\n    }\n\n    if (command === \"public-key\") {\n      const artifact = await createPublicKeyArtifact({\n        identity: await resolveSealIdentityFromEnv(env),\n      });\n      outputResult(writer, true, quiet, artifact);\n      return EXIT_SUCCESS;\n    }\n\n    throw new SealCliError(\n      \"Usage: seal identity create [--out <path>] [--words 12|24] [--passphrase <value>] [--mnemonic-out <path>] [--json] [--quiet]\\n\" +\n        \"       seal manifest create --input <path> [--out <path>] [--json] [--quiet]\\n\" +\n        \"       seal sign --input <path> [--recipient <age...>] [--out <path>] [--json] [--quiet]\\n\" +\n        \"       seal verify --proof <proof.json> --input <path> [--json] [--quiet]\\n\" +\n        \"       seal verify --artifact <artifact.json> [--json] [--quiet]\\n\" +\n        \"       seal public-key [--json] [--quiet]\",\n      EXIT_FAILURE,\n    );\n  } catch (error) {\n    if (error instanceof Error && error.message.includes(\"Proof\")) {\n      return outputError(writer, json, new SealCliError(error.message, EXIT_INVALID_PROOF));\n    }\n    if (\n      error instanceof Error &&\n      (error.message.includes(\"public key\") ||\n        error.message.includes(\"SEAL_IDENTITY\") ||\n        error.message.includes(\"identity\"))\n    ) {\n      return outputError(writer, json, new SealCliError(error.message, EXIT_KEY_CONFIG));\n    }\n    return outputError(writer, json, error);\n  }\n}\n\nconst isDirectRun =\n  typeof process !== \"undefined\" &&\n  process.argv[1] &&\n  fileURLToPath(import.meta.url) === resolve(process.argv[1]);\n\nif (isDirectRun) {\n  runCli(process.argv.slice(2)).then((exitCode) => {\n    process.exitCode = exitCode;\n  });\n}\n"],"names":["result"],"mappings":"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"}

package/dist/crypto.js

@@ -0,0 +1,41 @@
+import { createIdentity, createIdentityFromMnemonic, createMnemonicIdentity, serializeIdentity, parseIdentity, deriveKeyId, signUtf8, verifyUtf8 } from "@ternent/identity";
+const SEAL_SIGNATURE_CONTEXT = "ternent-seal/v2";
+async function createSealIdentity(createdAt = new Date().toISOString()) {
+  return createIdentity(createdAt);
+}
+async function createSealIdentityFromMnemonic(input) {
+  return createIdentityFromMnemonic(input);
+}
+async function createSealMnemonicIdentity(input = {}) {
+  return createMnemonicIdentity(input);
+}
+function exportIdentityJson(identity) {
+  return serializeIdentity(identity);
+}
+async function resolveSealSigner(input) {
+  const identity = parseIdentity(input.identity);
+  const keyId = await deriveKeyId(identity.publicKey);
+  if (keyId !== identity.keyId) {
+    throw new Error("Identity keyId does not match the signer public key.");
+  }
+  return {
+    identity,
+    publicKey: identity.publicKey,
+    keyId
+  };
+}
+async function signSealUtf8(identity, value) {
+  return signUtf8(identity, value, {
+    context: SEAL_SIGNATURE_CONTEXT
+  });
+}
+async function verifySealUtf8(signature, value, publicKey) {
+  return verifyUtf8(publicKey, value, signature, {
+    context: SEAL_SIGNATURE_CONTEXT
+  });
+}
+async function verifyPublicKeyKeyId(publicKey, keyId) {
+  return await deriveKeyId(publicKey) === keyId;
+}
+export { SEAL_SIGNATURE_CONTEXT, createSealIdentity, createSealIdentityFromMnemonic, createSealMnemonicIdentity, exportIdentityJson, resolveSealSigner, signSealUtf8, verifyPublicKeyKeyId, verifySealUtf8 };
+//# sourceMappingURL=crypto.js.map

package/dist/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sources":["../src/crypto.ts"],"sourcesContent":["import {\n  createIdentity,\n  createIdentityFromMnemonic,\n  createMnemonicIdentity,\n  deriveKeyId,\n  parseIdentity,\n  serializeIdentity,\n  signUtf8,\n  verifyUtf8,\n  type SerializedIdentity,\n} from \"@ternent/identity\";\n\nexport type SealSignerInput = {\n  identity: SerializedIdentity;\n};\n\nexport type ResolvedSealSigner = {\n  identity: SerializedIdentity;\n  publicKey: string;\n  keyId: string;\n};\n\nexport const SEAL_SIGNATURE_CONTEXT = \"ternent-seal/v2\";\n\nexport async function createSealIdentity(\n  createdAt = new Date().toISOString(),\n): Promise<SerializedIdentity> {\n  return createIdentity(createdAt);\n}\n\nexport async function createSealIdentityFromMnemonic(input: {\n  mnemonic: string;\n  passphrase?: string;\n  createdAt?: string;\n}): Promise<SerializedIdentity> {\n  return createIdentityFromMnemonic(input);\n}\n\nexport async function createSealMnemonicIdentity(\n  input: {\n    words?: 12 | 24;\n    passphrase?: string;\n    createdAt?: string;\n  } = {},\n): Promise<{ identity: SerializedIdentity; mnemonic: string }> {\n  return createMnemonicIdentity(input);\n}\n\nexport function exportIdentityJson(identity: SerializedIdentity): string {\n  return serializeIdentity(identity);\n}\n\nexport async function resolveSealSigner(input: SealSignerInput): Promise<ResolvedSealSigner> {\n  const identity = parseIdentity(input.identity);\n  const keyId = await deriveKeyId(identity.publicKey);\n  if (keyId !== identity.keyId) {\n    throw new Error(\"Identity keyId does not match the signer public key.\");\n  }\n\n  return {\n    identity,\n    publicKey: identity.publicKey,\n    keyId,\n  };\n}\n\nexport async function signSealUtf8(identity: SerializedIdentity, value: string): Promise<string> {\n  return signUtf8(identity, value, {\n    context: SEAL_SIGNATURE_CONTEXT,\n  });\n}\n\nexport async function verifySealUtf8(\n  signature: string,\n  value: string,\n  publicKey: string,\n): Promise<boolean> {\n  return verifyUtf8(publicKey, value, signature, {\n    context: SEAL_SIGNATURE_CONTEXT,\n  });\n}\n\nexport async function verifyPublicKeyKeyId(publicKey: string, keyId: string): Promise<boolean> {\n  return (await deriveKeyId(publicKey)) === keyId;\n}\n"],"names":[],"mappings":";AAsBO,MAAM,yBAAyB;AAEtC,eAAsB,mBACpB,YAAY,IAAI,KAAK,EAAE,eACM;AAC7B,SAAO,eAAe,SAAS;AACjC;AAEA,eAAsB,+BAA+B,OAIrB;AAC9B,SAAO,2BAA2B,KAAK;AACzC;AAEsB,eAAA,2BACpB,QAII,IACyD;AAC7D,SAAO,uBAAuB,KAAK;AACrC;AAEO,SAAS,mBAAmB,UAAsC;AACvE,SAAO,kBAAkB,QAAQ;AACnC;AAEA,eAAsB,kBAAkB,OAAqD;AACrF,QAAA,WAAW,cAAc,MAAM,QAAQ;AAC7C,QAAM,QAAQ,MAAM,YAAY,SAAS,SAAS;AAC9C,MAAA,UAAU,SAAS,OAAO;AACtB,UAAA,IAAI,MAAM,sDAAsD;AAAA,EACxE;AAEO,SAAA;AAAA,IACL;AAAA,IACA,WAAW,SAAS;AAAA,IACpB;AAAA,EAAA;AAEJ;AAEsB,eAAA,aAAa,UAA8B,OAAgC;AACxF,SAAA,SAAS,UAAU,OAAO;AAAA,IAC/B,SAAS;AAAA,EAAA,CACV;AACH;AAEsB,eAAA,eACpB,WACA,OACA,WACkB;AACX,SAAA,WAAW,WAAW,OAAO,WAAW;AAAA,IAC7C,SAAS;AAAA,EAAA,CACV;AACH;AAEsB,eAAA,qBAAqB,WAAmB,OAAiC;AACrF,SAAA,MAAM,YAAY,SAAS,MAAO;AAC5C;;"}

package/dist/errors.js

@@ -0,0 +1,65 @@
+import { ArmourValidationError, ArmourError } from "@ternent/armour";
+const EXIT_SUCCESS = 0;
+const EXIT_FAILURE = 1;
+const EXIT_HASH_MISMATCH = 2;
+const EXIT_SIGNATURE_INVALID = 3;
+const EXIT_INVALID_PROOF = 4;
+const EXIT_KEY_CONFIG = 5;
+class SealError extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+}
+class SealArtifactError extends SealError {
+}
+class SealCliError extends Error {
+  exitCode;
+  constructor(message, exitCode = EXIT_FAILURE) {
+    super(message);
+    this.name = "SealCliError";
+    this.exitCode = exitCode;
+  }
+}
+function getExitCode(error) {
+  if (error instanceof SealCliError) {
+    return error.exitCode;
+  }
+  return EXIT_FAILURE;
+}
+function unsupportedEncryptionModeError(message = "Seal does not support this encryption mode.") {
+  return new SealArtifactError("SEAL_UNSUPPORTED_ENCRYPTION_MODE", message);
+}
+function toSealEncryptionError(error) {
+  if (error instanceof SealArtifactError) {
+    return error;
+  }
+  if (error instanceof ArmourValidationError && (error.code === "ARMOUR_EMPTY_RECIPIENTS" || error.code === "ARMOUR_INVALID_RECIPIENT")) {
+    return new SealArtifactError(
+      "SEAL_INVALID_RECIPIENT",
+      "Recipient must be a valid age recipient string.",
+      error
+    );
+  }
+  if (error instanceof ArmourError) {
+    return new SealArtifactError("SEAL_ENCRYPTION_FAILED", "Failed to encrypt payload.", error);
+  }
+  return new SealArtifactError("SEAL_ENCRYPTION_FAILED", "Failed to encrypt payload.", error);
+}
+function toSealDecryptionError(error) {
+  if (error instanceof SealArtifactError) {
+    return error;
+  }
+  if (error instanceof ArmourError) {
+    return new SealArtifactError("SEAL_DECRYPTION_FAILED", "Failed to decrypt payload.", error);
+  }
+  return new SealArtifactError("SEAL_DECRYPTION_FAILED", "Failed to decrypt payload.", error);
+}
+export { EXIT_FAILURE, EXIT_HASH_MISMATCH, EXIT_INVALID_PROOF, EXIT_KEY_CONFIG, EXIT_SIGNATURE_INVALID, EXIT_SUCCESS, SealArtifactError, SealCliError, SealError, getExitCode, toSealDecryptionError, toSealEncryptionError, unsupportedEncryptionModeError };
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../src/errors.ts"],"sourcesContent":["import { ArmourError, ArmourValidationError } from \"@ternent/armour\";\n\nexport const EXIT_SUCCESS = 0;\nexport const EXIT_FAILURE = 1;\nexport const EXIT_HASH_MISMATCH = 2;\nexport const EXIT_SIGNATURE_INVALID = 3;\nexport const EXIT_INVALID_PROOF = 4;\nexport const EXIT_KEY_CONFIG = 5;\n\nexport type SealErrorCode =\n  | \"SEAL_INVALID_RECIPIENT\"\n  | \"SEAL_ENCRYPTION_FAILED\"\n  | \"SEAL_DECRYPTION_FAILED\"\n  | \"SEAL_UNSUPPORTED_ENCRYPTION_MODE\";\n\nexport class SealError extends Error {\n  readonly code: SealErrorCode;\n  readonly cause?: unknown;\n\n  constructor(code: SealErrorCode, message: string, cause?: unknown) {\n    super(message);\n    this.name = new.target.name;\n    this.code = code;\n    if (cause !== undefined) {\n      this.cause = cause;\n    }\n  }\n}\n\nexport class SealArtifactError extends SealError {}\n\nexport class SealCliError extends Error {\n  exitCode: number;\n\n  constructor(message: string, exitCode = EXIT_FAILURE) {\n    super(message);\n    this.name = \"SealCliError\";\n    this.exitCode = exitCode;\n  }\n}\n\nexport function getExitCode(error: unknown): number {\n  if (error instanceof SealCliError) {\n    return error.exitCode;\n  }\n  return EXIT_FAILURE;\n}\n\nexport function unsupportedEncryptionModeError(\n  message = \"Seal does not support this encryption mode.\",\n): SealArtifactError {\n  return new SealArtifactError(\"SEAL_UNSUPPORTED_ENCRYPTION_MODE\", message);\n}\n\nexport function toSealEncryptionError(error: unknown): SealArtifactError {\n  if (error instanceof SealArtifactError) {\n    return error;\n  }\n\n  if (\n    error instanceof ArmourValidationError &&\n    (error.code === \"ARMOUR_EMPTY_RECIPIENTS\" || error.code === \"ARMOUR_INVALID_RECIPIENT\")\n  ) {\n    return new SealArtifactError(\n      \"SEAL_INVALID_RECIPIENT\",\n      \"Recipient must be a valid age recipient string.\",\n      error,\n    );\n  }\n\n  if (error instanceof ArmourError) {\n    return new SealArtifactError(\"SEAL_ENCRYPTION_FAILED\", \"Failed to encrypt payload.\", error);\n  }\n\n  return new SealArtifactError(\"SEAL_ENCRYPTION_FAILED\", \"Failed to encrypt payload.\", error);\n}\n\nexport function toSealDecryptionError(error: unknown): SealArtifactError {\n  if (error instanceof SealArtifactError) {\n    return error;\n  }\n\n  if (error instanceof ArmourError) {\n    return new SealArtifactError(\"SEAL_DECRYPTION_FAILED\", \"Failed to decrypt payload.\", error);\n  }\n\n  return new SealArtifactError(\"SEAL_DECRYPTION_FAILED\", \"Failed to decrypt payload.\", error);\n}\n"],"names":[],"mappings":";AAEO,MAAM,eAAe;AACrB,MAAM,eAAe;AACrB,MAAM,qBAAqB;AAC3B,MAAM,yBAAyB;AAC/B,MAAM,qBAAqB;AAC3B,MAAM,kBAAkB;AAQxB,MAAM,kBAAkB,MAAM;AAAA,EAC1B;AAAA,EACA;AAAA,EAET,YAAY,MAAqB,SAAiB,OAAiB;AACjE,UAAM,OAAO;AACb,SAAK,OAAO,WAAW;AACvB,SAAK,OAAO;AACZ,QAAI,UAAU,QAAW;AACvB,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AACF;AAEO,MAAM,0BAA0B,UAAU;AAAC;AAE3C,MAAM,qBAAqB,MAAM;AAAA,EACtC;AAAA,EAEA,YAAY,SAAiB,WAAW,cAAc;AACpD,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW;AAAA,EAClB;AACF;AAEO,SAAS,YAAY,OAAwB;AAClD,MAAI,iBAAiB,cAAc;AACjC,WAAO,MAAM;AAAA,EACf;AACO,SAAA;AACT;AAEgB,SAAA,+BACd,UAAU,+CACS;AACZ,SAAA,IAAI,kBAAkB,oCAAoC,OAAO;AAC1E;AAEO,SAAS,sBAAsB,OAAmC;AACvE,MAAI,iBAAiB,mBAAmB;AAC/B,WAAA;AAAA,EACT;AAEA,MACE,iBAAiB,0BAChB,MAAM,SAAS,6BAA6B,MAAM,SAAS,6BAC5D;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ;AAEA,MAAI,iBAAiB,aAAa;AAChC,WAAO,IAAI,kBAAkB,0BAA0B,8BAA8B,KAAK;AAAA,EAC5F;AAEA,SAAO,IAAI,kBAAkB,0BAA0B,8BAA8B,KAAK;AAC5F;AAEO,SAAS,sBAAsB,OAAmC;AACvE,MAAI,iBAAiB,mBAAmB;AAC/B,WAAA;AAAA,EACT;AAEA,MAAI,iBAAiB,aAAa;AAChC,WAAO,IAAI,kBAAkB,0BAA0B,8BAA8B,KAAK;AAAA,EAC5F;AAEA,SAAO,IAAI,kBAAkB,0BAA0B,8BAA8B,KAAK;AAC5F;;"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { SEAL_PROOF_TYPE, SEAL_PROOF_VERSION, SEAL_PUBLIC_KEY_TYPE, SEAL_SIGNATURE_ALGORITHM, createSealHash, createSealProof, createSealPublicKeyArtifact, getSealProofSignableFields, getSealProofSigningPayload, parseSealProofJson, parseSealPublicKeyJson, validateSealProofShape, validateSealPublicKeyShape, verifySealProofAgainstBytes, verifySealProofSignature } from "./proof.js";
+export { SEAL_ARTIFACT_MANIFEST_VERSION, SEAL_ARTIFACT_TYPE, SEAL_ARTIFACT_VERSION, createSealArtifact, decryptSealArtifactPayload, getSealArtifactUnsignedFields, parseSealArtifactJson, validateSealArtifactShape, verifySealArtifact } from "./artifact.js";
+export { SEAL_MANIFEST_TYPE, SEAL_MANIFEST_VERSION, parseSealManifestJson, stringifySealManifest, validateSealManifestShape } from "./manifest.js";
+export { SEAL_SIGNATURE_CONTEXT, createSealIdentity, createSealIdentityFromMnemonic, createSealMnemonicIdentity, exportIdentityJson, resolveSealSigner, signSealUtf8, verifyPublicKeyKeyId, verifySealUtf8 } from "./crypto.js";
+export { EXIT_FAILURE, EXIT_HASH_MISMATCH, EXIT_INVALID_PROOF, EXIT_KEY_CONFIG, EXIT_SIGNATURE_INVALID, EXIT_SUCCESS, SealArtifactError, SealCliError, SealError, getExitCode, toSealDecryptionError, toSealEncryptionError, unsupportedEncryptionModeError } from "./errors.js";
+import "./chunks/utils.es-ad8f1dc4.js";
+import "@ternent/identity";
+import "@ternent/armour";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}