@hashgraphonline/standards-sdk 0.1.161 → 0.1.162

package/dist/es/standards-sdk.es112.js

@@ -1,481 +1,255 @@
-import { Logger } from "./standards-sdk.es117.js";
-import { HederaMirrorNode } from "./standards-sdk.es138.js";
-import { HRLResolver } from "./standards-sdk.es121.js";
-import { hash } from "./standards-sdk.es131.js";
-import { hcs26DiscoveryMetadataSchema, hcs26DiscoveryMetadataPatchSchema, hcs26DiscoveryRegisterSchema, hcs26DiscoveryRegisterLegacySchema, hcs26DiscoveryDeleteSchema, hcs26DiscoveryUpdateSchema, hcs26DiscoveryUpdateLegacySchema, hcs26VersionRegisterSchema, hcs26VersionRegisterLegacySchema, hcs26VersionUpdateSchema, hcs26VersionDeleteSchema, hcs26SkillManifestSchema } from "./standards-sdk.es111.js";
-function parseSemver(versionRaw) {
-  const trimmed = versionRaw.trim().replace(/^v/i, "");
-  const match = trimmed.match(
-    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
-  );
-  if (!match) {
-    return null;
-  }
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  const patch = Number(match[3]);
-  if (![major, minor, patch].every(Number.isFinite)) {
-    return null;
-  }
-  const prereleaseRaw = match[4];
-  const prerelease = prereleaseRaw ? prereleaseRaw.split(".").map((part) => {
-    if (/^(0|[1-9]\d*)$/.test(part)) {
-      return Number(part);
-    }
-    return part;
-  }) : [];
-  return { major, minor, patch, prerelease };
-}
-function compareSemver(a, b) {
-  if (a.major !== b.major) return a.major - b.major;
-  if (a.minor !== b.minor) return a.minor - b.minor;
-  if (a.patch !== b.patch) return a.patch - b.patch;
-  const aHasPre = a.prerelease.length > 0;
-  const bHasPre = b.prerelease.length > 0;
-  if (!aHasPre && bHasPre) return 1;
-  if (aHasPre && !bHasPre) return -1;
-  if (!aHasPre && !bHasPre) return 0;
-  const len = Math.max(a.prerelease.length, b.prerelease.length);
-  for (let index = 0; index < len; index += 1) {
-    const aId = a.prerelease[index];
-    const bId = b.prerelease[index];
-    if (aId === void 0 && bId !== void 0) return -1;
-    if (aId !== void 0 && bId === void 0) return 1;
-    if (aId === bId) continue;
-    if (typeof aId === "number" && typeof bId === "number") {
-      return aId - bId;
-    }
-    if (typeof aId === "number" && typeof bId === "string") {
-      return -1;
-    }
-    if (typeof aId === "string" && typeof bId === "number") {
-      return 1;
-    }
-    if (typeof aId === "string" && typeof bId === "string") {
-      return aId < bId ? -1 : 1;
+import { z } from "zod";
+const HCS26_PROTOCOL = "hcs-26";
+const hcs26TopicTypeEnumSchema = z.union([
+  z.literal(0),
+  // discovery
+  z.literal(1),
+  // version
+  z.literal(2)
+  // reputation (optional)
+]);
+const hcs26OperationEnumSchema = z.union([
+  z.literal(0),
+  // register
+  z.literal(1),
+  // update
+  z.literal(2),
+  // delete
+  z.literal(3)
+  // migrate
+]);
+const topicIdSchema = z.string().regex(/^[0-9]+\.[0-9]+\.[0-9]+$/);
+const hcs1HrlSchema = z.string().regex(/^hcs:\/\/1\/[0-9]+\.[0-9]+\.[0-9]+$/);
+const decentralizedAssetUriSchema = z.string().regex(
+  /^(hcs:\/\/1\/[0-9]+\.[0-9]+\.[0-9]+|ipfs:\/\/\S+|ar:\/\/\S+|ord:\/\/\S+)$/
+);
+const semverSchema = z.string().regex(
+  /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
+);
+function validateNormalizedRelativePath(pathRaw) {
+  const path = pathRaw.trim();
+  if (!path) {
+    throw new Error("Path must be non-empty");
+  }
+  if (path.startsWith("/")) {
+    throw new Error("Path must be relative");
+  }
+  if (path.includes("\\")) {
+    throw new Error('Path must use "/" separators');
+  }
+  const segments = path.split("/");
+  for (const segment of segments) {
+    if (!segment || segment === "." || segment === "..") {
+      throw new Error(
+        'Path must be normalized (no ".", "..", or empty segments)'
+      );
     }
   }
-  return 0;
-}
-function isActiveStatus(status) {
-  return !status || status === "active";
-}
-function normalizeUidString(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function resolveSequenceNumber(primary, fallback) {
-  if (typeof primary === "number") {
-    return primary;
-  }
-  if (typeof fallback === "number") {
-    return fallback;
-  }
-  return null;
-}
-function parseSequenceFromUid(uid) {
-  if (!/^\d+$/.test(uid)) {
-    return null;
-  }
-  const parsed = Number(uid);
-  return Number.isSafeInteger(parsed) ? parsed : null;
-}
-function ensureNonEmptyString(value, field) {
-  if (typeof value !== "string") {
-    throw new Error(`Expected ${field} to be a string`);
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error(`Expected ${field} to be a non-empty string`);
-  }
-  return trimmed;
 }
-function mergeDiscoveryMetadata(base, update) {
-  if (!update) {
-    return base;
-  }
-  return { ...base, ...update };
-}
-function normalizeDiscoveryRegister(input, messageSequenceNumber) {
-  const seq = typeof input.sequence_number === "number" ? input.sequence_number : typeof messageSequenceNumber === "number" ? messageSequenceNumber : void 0;
-  if ("t_id" in input) {
-    return {
-      p: "hcs-26",
-      op: "register",
-      t_id: ensureNonEmptyString(input.t_id, "t_id"),
-      account_id: ensureNonEmptyString(input.account_id, "account_id"),
-      metadata: input.metadata,
-      ...input.m ? { m: input.m } : {},
-      ...typeof seq === "number" ? { sequence_number: seq } : {}
-    };
-  }
-  return {
-    p: "hcs-26",
-    op: "register",
-    t_id: ensureNonEmptyString(input.version_registry, "version_registry"),
-    account_id: ensureNonEmptyString(input.publisher, "publisher"),
-    metadata: input.metadata,
-    ...input.m ? { m: input.m } : {},
-    ...typeof seq === "number" ? { sequence_number: seq } : {}
-  };
-}
-class Hcs26SkillRegistryResolver {
-  constructor(deps) {
-    this.network = deps.network;
-    this.logger = deps.logger ?? Logger.getInstance({
-      module: "HCS26Resolver",
-      level: "info"
-    });
-    this.mirrorNode = new HederaMirrorNode(
-      deps.network,
-      this.logger,
-      deps.mirrorNode
-    );
-    this.hrlResolver = new HRLResolver("warn");
-  }
-  async resolveDiscoveryMetadataHrl(metadataHrl, mode) {
-    const resolved = await this.hrlResolver.resolve(metadataHrl, {
-      network: this.network,
-      returnRaw: true
-    });
-    const bytes = resolved.content instanceof ArrayBuffer ? Buffer.from(resolved.content) : Buffer.from(String(resolved.content), "utf8");
-    let raw;
+const hcs1HrlOptionalSchema = z.string().regex(/^hcs:\/\/1\/[0-9]+\.[0-9]+\.[0-9]+$/).optional();
+const discoveryMetadataAuthorSchema = z.union([
+  z.string().min(1),
+  z.object({
+    name: z.string().min(1),
+    contact: z.string().min(1).optional(),
+    url: z.string().url().optional()
+  }).passthrough()
+]);
+const hcs26DiscoveryMetadataSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  author: discoveryMetadataAuthorSchema,
+  license: z.string().min(1),
+  tags: z.array(
+    z.union([
+      z.number().int().positive(),
+      z.string().regex(/^(0|[1-9]\d*)$/).transform((value) => Number.parseInt(value, 10))
+    ])
+  ).optional(),
+  homepage: z.string().url().optional(),
+  icon: z.union([z.string().url(), decentralizedAssetUriSchema]).optional(),
+  icon_hcs1: hcs1HrlOptionalSchema,
+  languages: z.array(z.string().min(1)).optional(),
+  capabilities: z.array(z.string().min(1)).optional(),
+  repo: z.string().url().optional(),
+  commit: z.string().regex(/^[0-9a-f]{7,64}$/i, "commit must be a git commit SHA").optional()
+}).passthrough();
+const hcs26DiscoveryMetadataPatchSchema = hcs26DiscoveryMetadataSchema.partial().passthrough();
+const hcs26DiscoveryRegisterSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("register"),
+  t_id: topicIdSchema,
+  account_id: z.string().min(1),
+  metadata: z.union([hcs26DiscoveryMetadataSchema, hcs1HrlSchema]),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26DiscoveryRegisterLegacySchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("register"),
+  version_registry: topicIdSchema,
+  publisher: z.string().min(1),
+  metadata: z.union([hcs26DiscoveryMetadataSchema, hcs1HrlSchema]),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26DiscoveryUpdateSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("update"),
+  uid: z.string().min(1),
+  account_id: z.string().min(1).optional(),
+  metadata: z.union([hcs26DiscoveryMetadataPatchSchema, hcs1HrlSchema]).optional(),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26DiscoveryUpdateLegacySchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("update"),
+  uid: z.string().min(1),
+  publisher: z.string().min(1).optional(),
+  metadata: z.union([hcs26DiscoveryMetadataPatchSchema, hcs1HrlSchema]).optional(),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26DiscoveryDeleteSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("delete"),
+  uid: z.string().min(1),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26DiscoveryMigrateSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("migrate"),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const checksumSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const hcs26VersionRegisterSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("register"),
+  skill_uid: z.number().int().positive(),
+  version: semverSchema,
+  t_id: topicIdSchema,
+  checksum: checksumSchema.optional(),
+  status: z.enum(["active", "deprecated", "yanked"]).optional(),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26VersionRegisterLegacySchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("register"),
+  skill_uid: z.number().int().positive(),
+  version: semverSchema,
+  manifest_hcs1: hcs1HrlSchema,
+  checksum: checksumSchema.optional(),
+  status: z.enum(["active", "deprecated", "yanked"]).optional(),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26VersionUpdateSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("update"),
+  uid: z.string().min(1),
+  status: z.enum(["active", "deprecated", "yanked"]).optional(),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26VersionDeleteSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("delete"),
+  uid: z.string().min(1),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26VersionMigrateSchema = z.object({
+  p: z.literal(HCS26_PROTOCOL),
+  op: z.literal("migrate"),
+  m: z.string().max(500).optional(),
+  sequence_number: z.number().int().optional()
+}).passthrough();
+const hcs26ManifestFileSchema = z.object({
+  path: z.string().min(1).superRefine((value, ctx) => {
     try {
-      raw = JSON.parse(bytes.toString("utf8"));
-    } catch {
-      throw new Error("Discovery metadata HRL content is not valid JSON");
-    }
-    const schema = mode === "full" ? hcs26DiscoveryMetadataSchema : hcs26DiscoveryMetadataPatchSchema;
-    const parsed = schema.safeParse(raw);
-    if (!parsed.success) {
-      throw new Error(`Invalid discovery metadata: ${parsed.error.message}`);
-    }
-    return this.normalizeDiscoveryMetadataObject(
-      parsed.data
-    );
-  }
-  normalizeDiscoveryMetadataObject(metadata) {
-    if (typeof metadata.icon !== "string" || metadata.icon.trim().length === 0) {
-      const iconLegacy = metadata.icon_hcs1;
-      if (typeof iconLegacy === "string" && iconLegacy.trim().length > 0) {
-        return { ...metadata, icon: iconLegacy };
-      }
-    }
-    return metadata;
-  }
-  async resolveDiscoveryMetadataUri(metadataUri, mode) {
-    const trimmed = metadataUri.trim();
-    if (trimmed.startsWith("hcs://1/")) {
-      return this.resolveDiscoveryMetadataHrl(trimmed, mode);
-    }
-    throw new Error(`Unsupported discovery metadata URI: ${trimmed}`);
-  }
-  resolveDiscoveryMetadataObject(params) {
-    if (typeof params.metadata === "string") {
-      return this.resolveDiscoveryMetadataUri(params.metadata, params.mode);
-    }
-    const schema = params.mode === "full" ? hcs26DiscoveryMetadataSchema : hcs26DiscoveryMetadataPatchSchema;
-    const parsed = schema.safeParse(params.metadata);
-    if (!parsed.success) {
-      throw new Error(`Invalid discovery metadata: ${parsed.error.message}`);
-    }
-    return Promise.resolve(
-      this.normalizeDiscoveryMetadataObject(
-        parsed.data
-      )
-    );
-  }
-  async getDiscoveryRegister(params) {
-    const messages = await this.mirrorNode.getTopicMessages(
-      params.directoryTopicId,
-      {
-        sequenceNumber: `eq:${params.skillUid}`,
-        limit: 5,
-        order: "asc"
-      }
-    );
-    for (const message of messages) {
-      const parsedNew = hcs26DiscoveryRegisterSchema.safeParse(message);
-      const parsedLegacy = parsedNew.success ? null : hcs26DiscoveryRegisterLegacySchema.safeParse(message);
-      const parsed = parsedNew.success ? parsedNew : parsedLegacy && parsedLegacy.success ? parsedLegacy : null;
-      if (!parsed) {
-        continue;
-      }
-      const normalized = normalizeDiscoveryRegister(
-        parsed.data,
-        message.sequence_number
-      );
-      const seq = normalized.sequence_number;
-      if (typeof seq === "number" && seq === params.skillUid) {
-        const metadata = await this.resolveDiscoveryMetadataObject({
-          metadata: normalized.metadata,
-          mode: "full"
-        });
-        return { ...normalized, metadata };
-      }
-    }
-    return null;
-  }
-  async resolveDiscoveryRecord(params) {
-    const register = await this.getDiscoveryRegister({
-      directoryTopicId: params.directoryTopicId,
-      skillUid: params.skillUid
-    });
-    if (!register) {
-      return null;
-    }
-    const scanLimit = typeof params.scanLimit === "number" && params.scanLimit > 0 ? Math.min(5e3, Math.floor(params.scanLimit)) : 1e3;
-    const messages = await this.mirrorNode.getTopicMessages(
-      params.directoryTopicId,
-      {
-        limit: scanLimit,
-        order: "asc"
-      }
-    );
-    const uid = String(params.skillUid);
-    const registerSequence = resolveSequenceNumber(
-      register.sequence_number,
-      params.skillUid
-    );
-    let current = register;
-    for (const message of messages) {
-      const messageSequence = resolveSequenceNumber(
-        void 0,
-        message.sequence_number
-      );
-      const deleteParsed = hcs26DiscoveryDeleteSchema.safeParse(message);
-      if (deleteParsed.success && deleteParsed.data.uid === uid) {
-        const deleteSequence = resolveSequenceNumber(
-          deleteParsed.data.sequence_number,
-          messageSequence
-        );
-        if (registerSequence !== null && deleteSequence !== null && deleteSequence <= registerSequence) {
-          continue;
-        }
-        return null;
-      }
-      const updateParsedNew = hcs26DiscoveryUpdateSchema.safeParse(message);
-      const updateParsedLegacy = updateParsedNew.success ? null : hcs26DiscoveryUpdateLegacySchema.safeParse(message);
-      const updateParsed = updateParsedNew.success ? updateParsedNew : updateParsedLegacy && updateParsedLegacy.success ? updateParsedLegacy : null;
-      if (!updateParsed || updateParsed.data.uid !== uid) {
-        continue;
-      }
-      const updateSequence = resolveSequenceNumber(
-        updateParsed.data.sequence_number,
-        messageSequence
-      );
-      if (registerSequence !== null && updateSequence !== null && updateSequence <= registerSequence) {
-        continue;
-      }
-      const nextAccountId = "account_id" in updateParsed.data ? normalizeUidString(updateParsed.data.account_id) : normalizeUidString(updateParsed.data.publisher);
-      const nextMetadataRaw = updateParsed.data.metadata;
-      const nextMetadata = nextMetadataRaw !== void 0 ? await this.resolveDiscoveryMetadataObject({
-        metadata: nextMetadataRaw,
-        mode: "patch"
-      }) : void 0;
-      current = {
-        ...current,
-        ...nextAccountId ? { account_id: nextAccountId } : {},
-        metadata: mergeDiscoveryMetadata(current.metadata, nextMetadata)
-      };
-    }
-    return current;
-  }
-  async listVersionRegisters(params) {
-    const limit = typeof params.limit === "number" && params.limit > 0 ? Math.min(1e3, params.limit) : 500;
-    const messages = await this.mirrorNode.getTopicMessages(
-      params.versionRegistryTopicId,
-      {
-        limit,
-        order: "desc"
-      }
-    );
-    const registersByUid = /* @__PURE__ */ new Map();
-    const updatesByUid = /* @__PURE__ */ new Map();
-    const deletedByUid = /* @__PURE__ */ new Map();
-    for (const message of messages) {
-      const parsedNew = hcs26VersionRegisterSchema.safeParse(message);
-      const parsedLegacy = parsedNew.success ? null : hcs26VersionRegisterLegacySchema.safeParse(message);
-      const registerParsed = parsedNew.success ? parsedNew : parsedLegacy && parsedLegacy.success ? parsedLegacy : null;
-      if (registerParsed) {
-        if (registerParsed.data.skill_uid !== params.skillUid) {
-          continue;
-        }
-        const uid = typeof registerParsed.data.sequence_number === "number" ? String(registerParsed.data.sequence_number) : typeof message.sequence_number === "number" ? String(message.sequence_number) : null;
-        if (uid) {
-          const registerSequence = resolveSequenceNumber(
-            registerParsed.data.sequence_number,
-            message.sequence_number
-          );
-          registersByUid.set(uid, {
-            register: registerParsed.data,
-            sequenceNumber: registerSequence
-          });
-        }
-        continue;
-      }
-      const updateParsed = hcs26VersionUpdateSchema.safeParse(message);
-      if (updateParsed.success) {
-        const uid = updateParsed.data.uid.trim();
-        const list = updatesByUid.get(uid) ?? [];
-        list.push({
-          update: updateParsed.data,
-          sequenceNumber: resolveSequenceNumber(
-            updateParsed.data.sequence_number,
-            message.sequence_number
-          )
-        });
-        updatesByUid.set(uid, list);
-        continue;
-      }
-      const deleteParsed = hcs26VersionDeleteSchema.safeParse(message);
-      if (deleteParsed.success) {
-        const uid = deleteParsed.data.uid.trim();
-        const list = deletedByUid.get(uid) ?? [];
-        const sequenceNumber = resolveSequenceNumber(
-          deleteParsed.data.sequence_number,
-          message.sequence_number
-        );
-        if (sequenceNumber !== null) {
-          list.push(sequenceNumber);
-          deletedByUid.set(uid, list);
-        }
-      }
-    }
-    const entries = [];
-    for (const [uid, registerState] of registersByUid.entries()) {
-      const registerSequence = registerState.sequenceNumber ?? parseSequenceFromUid(uid);
-      const deleteSequences = deletedByUid.get(uid) ?? [];
-      const hasDeleteAfterRegister = deleteSequences.some(
-        (sequence) => registerSequence === null ? true : sequence > registerSequence
-      );
-      if (hasDeleteAfterRegister) {
-        continue;
-      }
-      const updates = updatesByUid.get(uid);
-      if (!updates || updates.length === 0) {
-        entries.push(registerState.register);
-        continue;
-      }
-      const sorted = [...updates].filter(
-        (update) => registerSequence === null ? true : update.sequenceNumber !== null && update.sequenceNumber > registerSequence
-      ).sort((a, b) => {
-        const aSeq = a.sequenceNumber ?? 0;
-        const bSeq = b.sequenceNumber ?? 0;
-        return aSeq - bSeq;
-      });
-      if (sorted.length === 0) {
-        entries.push(registerState.register);
-        continue;
-      }
-      const final = sorted.reduce((acc, updateState) => {
-        if (updateState.update.status) {
-          return { ...acc, status: updateState.update.status };
-        }
-        return acc;
-      }, registerState.register);
-      entries.push(final);
-    }
-    return entries;
-  }
-  async getLatestVersionRegister(params) {
-    const entries = await this.listVersionRegisters({
-      versionRegistryTopicId: params.versionRegistryTopicId,
-      skillUid: params.skillUid,
-      limit: 100
-    });
-    const active = entries.filter((entry) => isActiveStatus(entry.status));
-    if (active.length === 0) {
-      return null;
-    }
-    let best = active[0];
-    let bestParsed = parseSemver(best.version);
-    for (let index = 1; index < active.length; index += 1) {
-      const candidate = active[index];
-      const candidateParsed = parseSemver(candidate.version);
-      if (!bestParsed && candidateParsed) {
-        best = candidate;
-        bestParsed = candidateParsed;
-        continue;
-      }
-      if (bestParsed && candidateParsed) {
-        const cmp = compareSemver(candidateParsed, bestParsed);
-        if (cmp > 0) {
-          best = candidate;
-          bestParsed = candidateParsed;
-          continue;
-        }
-        if (cmp === 0) {
-          const bestSeq = typeof best.sequence_number === "number" ? best.sequence_number : 0;
-          const candSeq = typeof candidate.sequence_number === "number" ? candidate.sequence_number : 0;
-          if (candSeq > bestSeq) {
-            best = candidate;
-            bestParsed = candidateParsed;
-          }
-        }
-      }
-    }
-    return best;
-  }
-  async resolveManifest(params) {
-    const manifestHrl = typeof params.manifestHrl === "string" && params.manifestHrl.trim().length > 0 ? params.manifestHrl.trim() : typeof params.manifestTopicId === "string" && params.manifestTopicId.trim().length > 0 ? `hcs://1/${params.manifestTopicId.trim()}` : null;
-    if (!manifestHrl) {
-      throw new Error("Manifest HRL or topic id is required");
-    }
-    const resolved = await this.hrlResolver.resolve(manifestHrl, {
-      network: this.network,
-      returnRaw: true
+      validateNormalizedRelativePath(value);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message });
+    }
+  }),
+  hrl: hcs1HrlSchema,
+  sha256: z.string().regex(/^[0-9a-f]{64}$/),
+  mime: z.string().min(1)
+}).passthrough();
+const hcs26SkillManifestSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  version: semverSchema,
+  license: z.string().min(1),
+  author: discoveryMetadataAuthorSchema,
+  tags: z.array(
+    z.union([
+      z.number().int().positive(),
+      z.string().regex(/^(0|[1-9]\d*)$/).transform((value) => Number.parseInt(value, 10))
+    ])
+  ).optional(),
+  homepage: z.string().url().optional(),
+  languages: z.array(z.string().min(1)).optional(),
+  repo: z.string().url().optional(),
+  commit: z.string().regex(/^[0-9a-f]{7,64}$/i, "commit must be a git commit SHA").optional(),
+  entrypoints: z.array(
+    z.object({
+      path: z.string().min(1),
+      language: z.string().min(1),
+      args: z.array(z.string()).optional()
+    }).passthrough()
+  ).optional(),
+  files: z.array(hcs26ManifestFileSchema).min(1)
+}).passthrough().superRefine((value, ctx) => {
+  const hasSkillMd = value.files.some((file) => file.path === "SKILL.md");
+  if (!hasSkillMd) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'SKILL.md must be present in the manifest files list with path "SKILL.md".',
+      path: ["files"]
     });
-    const contentType = resolved.contentType ?? "";
-    if (!contentType.toLowerCase().startsWith("application/json")) {
-      throw new Error(
-        `Expected application/json for manifest, got ${resolved.contentType ?? "unknown"}`
-      );
-    }
-    const bytes = resolved.content instanceof ArrayBuffer ? Buffer.from(resolved.content) : Buffer.from(String(resolved.content), "utf8");
-    const sha256Hex = await hash(bytes, "sha256");
-    let raw;
-    try {
-      raw = JSON.parse(bytes.toString("utf8"));
-    } catch {
-      throw new Error("Manifest content is not valid JSON");
-    }
-    const parsed = hcs26SkillManifestSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new Error(`Invalid HCS-26 manifest: ${parsed.error.message}`);
-    }
-    const hasSkillMd = parsed.data.files.some((file) => file.path === "SKILL.md");
-    if (!hasSkillMd) {
-      throw new Error(
-        'HCS-26 manifest must include SKILL.md at path "SKILL.md"'
-      );
-    }
-    return { manifest: parsed.data, raw, sha256Hex };
   }
-  async verifyVersionRegisterMatchesManifest(params) {
-    const checksumRaw = params.versionRegister.checksum;
-    if (!checksumRaw) {
-      this.logger.warn(
-        "HCS-26 version register is missing checksum; skipping manifest verification."
-      );
-      return;
-    }
-    const checksum = checksumRaw.trim();
-    if (!checksum.startsWith("sha256:")) {
-      throw new Error(`Unsupported checksum: ${checksum}`);
-    }
-    const expectedHex = checksum.slice("sha256:".length);
-    if (params.manifestSha256Hex !== expectedHex) {
-      throw new Error(
-        `Manifest checksum mismatch (expected ${expectedHex}, got ${params.manifestSha256Hex})`
-      );
-    }
-  }
-}
+});
+const hcs26DiscoveryMessageSchema = z.union([
+  hcs26DiscoveryRegisterSchema,
+  hcs26DiscoveryRegisterLegacySchema,
+  hcs26DiscoveryUpdateSchema,
+  hcs26DiscoveryUpdateLegacySchema,
+  hcs26DiscoveryDeleteSchema,
+  hcs26DiscoveryMigrateSchema
+]);
+const hcs26VersionMessageSchema = z.union([
+  hcs26VersionRegisterSchema,
+  hcs26VersionRegisterLegacySchema,
+  hcs26VersionUpdateSchema,
+  hcs26VersionDeleteSchema,
+  hcs26VersionMigrateSchema
+]);
 export {
-  Hcs26SkillRegistryResolver
+  HCS26_PROTOCOL,
+  hcs26DiscoveryDeleteSchema,
+  hcs26DiscoveryMessageSchema,
+  hcs26DiscoveryMetadataPatchSchema,
+  hcs26DiscoveryMetadataSchema,
+  hcs26DiscoveryMigrateSchema,
+  hcs26DiscoveryRegisterLegacySchema,
+  hcs26DiscoveryRegisterSchema,
+  hcs26DiscoveryUpdateLegacySchema,
+  hcs26DiscoveryUpdateSchema,
+  hcs26ManifestFileSchema,
+  hcs26OperationEnumSchema,
+  hcs26SkillManifestSchema,
+  hcs26TopicTypeEnumSchema,
+  hcs26VersionDeleteSchema,
+  hcs26VersionMessageSchema,
+  hcs26VersionMigrateSchema,
+  hcs26VersionRegisterLegacySchema,
+  hcs26VersionRegisterSchema,
+  hcs26VersionUpdateSchema
 };
 //# sourceMappingURL=standards-sdk.es112.js.map