@hol-org/rb-client 0.1.176 → 0.1.178

package/dist/index.cjs

@@ -297,13 +297,6 @@ var metadataFacetSchema = import_zod2.z.record(
     jsonValueSchema
   ])
 ).optional();
-var searchHitMetadataSchema = import_zod2.z.object({
-  delegationRoles: jsonValueSchema.optional(),
-  delegationTaskTags: jsonValueSchema.optional(),
-  delegationProtocols: jsonValueSchema.optional(),
-  delegationSummary: jsonValueSchema.optional(),
-  delegationSignals: jsonValueSchema.optional()
-}).passthrough();
 var searchHitSchema = import_zod2.z.object({
   id: import_zod2.z.string(),
   uaid: import_zod2.z.string(),
@@ -312,7 +305,7 @@ var searchHitSchema = import_zod2.z.object({
   description: import_zod2.z.string().optional(),
   capabilities: import_zod2.z.array(capabilityValueSchema),
   endpoints: import_zod2.z.union([import_zod2.z.record(jsonValueSchema), import_zod2.z.array(import_zod2.z.string())]).optional(),
-  metadata: searchHitMetadataSchema.optional(),
+  metadata: import_zod2.z.record(jsonValueSchema).optional(),
   metadataFacet: metadataFacetSchema,
   profile: agentProfileSchema.optional(),
   protocols: import_zod2.z.array(import_zod2.z.string()).optional(),
@@ -358,22 +351,13 @@ var resolveResponseSchema = import_zod2.z.object({
 });
 var delegationPlanCandidateSchema = import_zod2.z.object({
   uaid: import_zod2.z.string(),
-  label: import_zod2.z.string(),
-  registry: import_zod2.z.string().optional(),
-  agent: searchHitSchema,
   score: import_zod2.z.number(),
-  matchedQueries: import_zod2.z.array(import_zod2.z.string()).optional(),
-  matchedRoles: import_zod2.z.array(import_zod2.z.string()).optional(),
-  matchedProtocols: import_zod2.z.array(import_zod2.z.string()).optional(),
-  matchedSurfaces: import_zod2.z.array(import_zod2.z.string()).optional(),
-  matchedLanguages: import_zod2.z.array(import_zod2.z.string()).optional(),
-  matchedArtifacts: import_zod2.z.array(import_zod2.z.string()).optional(),
-  matchedTaskTags: import_zod2.z.array(import_zod2.z.string()).optional(),
-  reasons: import_zod2.z.array(import_zod2.z.string()).optional(),
-  suggestedMessage: import_zod2.z.string().optional(),
-  trustScore: import_zod2.z.number().optional(),
-  verified: import_zod2.z.boolean().optional(),
-  communicationSupported: import_zod2.z.boolean().optional(),
+  displayName: import_zod2.z.string().optional(),
+  summary: import_zod2.z.string().optional(),
+  protocols: import_zod2.z.array(import_zod2.z.string()).optional(),
+  surfaces: import_zod2.z.array(import_zod2.z.string()).optional(),
+  languages: import_zod2.z.array(import_zod2.z.string()).optional(),
+  artifacts: import_zod2.z.array(import_zod2.z.string()).optional(),
   availability: import_zod2.z.boolean().optional(),
   explanation: import_zod2.z.string().optional()
 }).passthrough();
@@ -962,6 +946,151 @@ var creditPurchaseResponseSchema = import_zod2.z.object({
   transactionId: import_zod2.z.string(),
   consensusTimestamp: import_zod2.z.string().nullable().optional()
 });
+var creditProviderSummarySchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  publishableKey: import_zod2.z.string().optional(),
+  currency: import_zod2.z.string().optional(),
+  centsPerHbar: import_zod2.z.number().nullable().optional()
+});
+var creditProvidersResponseSchema = import_zod2.z.object({
+  providers: import_zod2.z.array(creditProviderSummarySchema)
+});
+var creditBalanceResponseSchema = import_zod2.z.object({
+  accountId: import_zod2.z.string(),
+  balance: import_zod2.z.number(),
+  balanceRecord: jsonValueSchema.optional(),
+  timestamp: import_zod2.z.string().optional()
+});
+var guardPlanIdSchema = import_zod2.z.enum(["free", "pro", "team", "enterprise"]);
+var guardBucketBalanceSchema = import_zod2.z.object({
+  bucketId: import_zod2.z.enum([
+    "registry_credits",
+    "chat_credits",
+    "guard_credits",
+    "org_policy_credits"
+  ]),
+  label: import_zod2.z.string(),
+  availableCredits: import_zod2.z.number(),
+  includedMonthlyCredits: import_zod2.z.number().nullable().optional()
+});
+var guardPrincipalSchema = import_zod2.z.object({
+  signedIn: import_zod2.z.boolean(),
+  userId: import_zod2.z.string().optional(),
+  email: import_zod2.z.string().optional(),
+  accountId: import_zod2.z.string().optional(),
+  stripeCustomerId: import_zod2.z.string().optional(),
+  roles: import_zod2.z.array(import_zod2.z.string())
+});
+var guardEntitlementsSchema = import_zod2.z.object({
+  planId: guardPlanIdSchema,
+  includedMonthlyCredits: import_zod2.z.number(),
+  deviceLimit: import_zod2.z.number(),
+  retentionDays: import_zod2.z.number(),
+  syncEnabled: import_zod2.z.boolean(),
+  premiumFeedsEnabled: import_zod2.z.boolean(),
+  teamPolicyEnabled: import_zod2.z.boolean()
+});
+var guardSessionResponseSchema = import_zod2.z.object({
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: import_zod2.z.object({
+    accountId: import_zod2.z.string(),
+    availableCredits: import_zod2.z.number()
+  }).nullable(),
+  bucketingMode: import_zod2.z.enum(["shared-ledger", "product-bucketed"]),
+  buckets: import_zod2.z.array(guardBucketBalanceSchema)
+});
+var guardBalanceResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  bucketingMode: import_zod2.z.enum(["shared-ledger", "product-bucketed"]),
+  buckets: import_zod2.z.array(guardBucketBalanceSchema)
+});
+var guardTrustMatchSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  verified: import_zod2.z.boolean(),
+  safetyScore: import_zod2.z.number().nullable().optional(),
+  trustScore: import_zod2.z.number().nullable().optional(),
+  href: import_zod2.z.string().optional(),
+  ecosystem: import_zod2.z.string().optional()
+});
+var guardTrustByHashResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  query: import_zod2.z.object({
+    sha256: import_zod2.z.string()
+  }),
+  match: guardTrustMatchSchema.nullable(),
+  evidence: import_zod2.z.array(import_zod2.z.string())
+});
+var guardTrustResolveResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  query: import_zod2.z.object({
+    ecosystem: import_zod2.z.string().optional(),
+    name: import_zod2.z.string().optional(),
+    version: import_zod2.z.string().optional()
+  }),
+  items: import_zod2.z.array(guardTrustMatchSchema)
+});
+var guardRevocationSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  reason: import_zod2.z.string(),
+  severity: import_zod2.z.enum(["low", "medium", "high"]),
+  publishedAt: import_zod2.z.string()
+});
+var guardRevocationResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardRevocationSchema)
+});
+var guardReceiptSchema = import_zod2.z.object({
+  receiptId: import_zod2.z.string(),
+  capturedAt: import_zod2.z.string(),
+  harness: import_zod2.z.string(),
+  deviceId: import_zod2.z.string(),
+  deviceName: import_zod2.z.string(),
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  artifactHash: import_zod2.z.string(),
+  policyDecision: import_zod2.z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  changedSinceLastApproval: import_zod2.z.boolean(),
+  publisher: import_zod2.z.string().optional(),
+  capabilities: import_zod2.z.array(import_zod2.z.string()),
+  summary: import_zod2.z.string()
+});
+var guardReceiptSyncResponseSchema = import_zod2.z.object({
+  syncedAt: import_zod2.z.string(),
+  receiptsStored: import_zod2.z.number()
+});
+var hbarPurchaseIntentResponseSchema = import_zod2.z.object({
+  transaction: import_zod2.z.string(),
+  transactionId: import_zod2.z.string(),
+  network: import_zod2.z.enum(["mainnet", "testnet"]),
+  accountId: import_zod2.z.string(),
+  treasuryAccountId: import_zod2.z.string(),
+  hbarAmount: import_zod2.z.number(),
+  credits: import_zod2.z.number(),
+  tinybarAmount: import_zod2.z.number(),
+  memo: import_zod2.z.string(),
+  centsPerHbar: import_zod2.z.number(),
+  validStart: import_zod2.z.string(),
+  validDurationSeconds: import_zod2.z.number(),
+  requiresManualSubmit: import_zod2.z.literal(true),
+  purchaseId: import_zod2.z.string()
+});
 var x402SettlementSchema = import_zod2.z.object({
   success: import_zod2.z.boolean().optional(),
   transaction: import_zod2.z.string().optional(),
@@ -1291,14 +1420,6 @@ var skillRegistryListResponseSchema = import_zod2.z.object({
   items: import_zod2.z.array(skillRegistryPublishSummarySchema),
   nextCursor: import_zod2.z.string().nullable()
 }).passthrough();
-var skillSecurityBreakdownResponseSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  version: import_zod2.z.string(),
-  jobId: import_zod2.z.string(),
-  createdAt: import_zod2.z.string(),
-  safety: skillSafetySummarySchema.nullable(),
-  findings: import_zod2.z.array(skillSafetyFindingSchema)
-}).passthrough();
 var skillCatalogChannelSchema = import_zod2.z.enum([
   "stable",
   "prerelease",
@@ -1352,58 +1473,190 @@ var skillDeprecationsResponseSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   items: import_zod2.z.array(skillDeprecationRecordSchema)
 }).passthrough();
-var skillPublisherQuickstartCommandSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  label: import_zod2.z.string(),
-  description: import_zod2.z.string(),
-  command: import_zod2.z.string(),
-  href: import_zod2.z.string().nullable().optional()
+var skillSecurityBreakdownFindingSchema = import_zod2.z.record(jsonValueSchema);
+var skillSecurityBreakdownSummarySchema = import_zod2.z.record(jsonValueSchema);
+var skillSecurityBreakdownResponseSchema = import_zod2.z.object({
+  jobId: import_zod2.z.string(),
+  score: import_zod2.z.number().nullable().optional(),
+  findings: import_zod2.z.array(skillSecurityBreakdownFindingSchema).optional(),
+  summary: skillSecurityBreakdownSummarySchema.optional(),
+  generatedAt: import_zod2.z.string().nullable().optional(),
+  scannerVersion: import_zod2.z.string().nullable().optional()
 }).passthrough();
-var skillPublisherTemplatePresetSchema = import_zod2.z.object({
-  presetId: import_zod2.z.string(),
+var skillBadgeMetricSchema = import_zod2.z.enum([
+  "version",
+  "version_verification",
+  "status",
+  "verification",
+  "repo_commit",
+  "manifest",
+  "domain",
+  "trust",
+  "tier",
+  "safety",
+  "upvotes",
+  "updated"
+]);
+var skillBadgeStyleSchema = import_zod2.z.enum([
+  "flat",
+  "flat-square",
+  "for-the-badge",
+  "plastic",
+  "social"
+]);
+var skillBadgeResponseSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.number().int(),
   label: import_zod2.z.string(),
-  description: import_zod2.z.string(),
-  recommendedFor: import_zod2.z.string(),
-  command: import_zod2.z.string()
+  message: import_zod2.z.string(),
+  color: import_zod2.z.string(),
+  style: skillBadgeStyleSchema.optional(),
+  isError: import_zod2.z.boolean().optional(),
+  cacheSeconds: import_zod2.z.number().int().optional()
 }).passthrough();
-var skillPublisherMetadataSchema = import_zod2.z.object({
-  cliPackageUrl: import_zod2.z.string(),
-  cliCommand: import_zod2.z.string(),
-  actionMarketplaceUrl: import_zod2.z.string(),
-  repositoryUrl: import_zod2.z.string(),
-  guideUrl: import_zod2.z.string().nullable().optional(),
-  docsUrl: import_zod2.z.string().nullable().optional(),
-  submitUrl: import_zod2.z.string().nullable().optional(),
-  skillsIndexUrl: import_zod2.z.string().nullable().optional(),
-  quickstartCommands: import_zod2.z.array(skillPublisherQuickstartCommandSchema),
-  templatePresets: import_zod2.z.array(skillPublisherTemplatePresetSchema)
+var skillRegistryTagsResponseSchema = import_zod2.z.object({
+  tags: import_zod2.z.array(import_zod2.z.string())
+}).passthrough();
+var skillRegistryCategoriesResponseSchema = import_zod2.z.object({
+  categories: import_zod2.z.array(import_zod2.z.string())
+}).passthrough();
+var skillResolverManifestResponseSchema = import_zod2.z.record(jsonValueSchema);
+var skillRegistryQuoteFileBreakdownSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  mimeType: import_zod2.z.string(),
+  estimatedCostHbar: import_zod2.z.number()
+}).passthrough();
+var skillRegistryQuoteResponseSchema = import_zod2.z.object({
+  quoteId: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  directoryTopicId: import_zod2.z.string(),
+  estimatedCostHbar: import_zod2.z.number(),
+  credits: import_zod2.z.number(),
+  usdCents: import_zod2.z.number(),
+  expiresAt: import_zod2.z.string(),
+  files: import_zod2.z.array(skillRegistryQuoteFileBreakdownSchema)
+}).passthrough();
+var skillRegistryJobStatusSchema = import_zod2.z.union([
+  import_zod2.z.literal("pending"),
+  import_zod2.z.literal("in_progress"),
+  import_zod2.z.literal("completed"),
+  import_zod2.z.literal("failed")
+]);
+var skillRegistryPublishResponseSchema = import_zod2.z.object({
+  jobId: import_zod2.z.string(),
+  status: skillRegistryJobStatusSchema,
+  credits: import_zod2.z.number().nullable().optional(),
+  usdCents: import_zod2.z.number().nullable().optional(),
+  quoteId: import_zod2.z.string().nullable().optional(),
+  createdAt: import_zod2.z.string(),
+  updatedAt: import_zod2.z.string(),
+  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")])
+}).passthrough();
+var skillRegistryJobStatusResponseSchema = import_zod2.z.object({
+  jobId: import_zod2.z.string(),
+  status: skillRegistryJobStatusSchema,
+  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]),
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  directoryTopicId: import_zod2.z.string(),
+  skillUid: import_zod2.z.number().int().nullable().optional(),
+  directorySequenceNumber: import_zod2.z.number().int().nullable().optional(),
+  versionRegistryTopicId: import_zod2.z.string().nullable().optional(),
+  packageTopicId: import_zod2.z.string().nullable().optional(),
+  manifestHrl: import_zod2.z.string().nullable().optional(),
+  skillJsonHrl: import_zod2.z.string().nullable().optional(),
+  iconHcs1: import_zod2.z.string().nullable().optional(),
+  tags: import_zod2.z.array(import_zod2.z.string()).nullable().optional(),
+  category: import_zod2.z.string().nullable().optional(),
+  files: import_zod2.z.array(skillRegistryFileDescriptorSchema).nullable().optional(),
+  quoteCredits: import_zod2.z.number().nullable().optional(),
+  quoteUsdCents: import_zod2.z.number().nullable().optional(),
+  safety: skillSafetySummarySchema.nullable().optional(),
+  reservationId: import_zod2.z.string().nullable().optional(),
+  totalCostHbar: import_zod2.z.number().nullable().optional(),
+  totalCostCredits: import_zod2.z.number().nullable().optional(),
+  failureReason: import_zod2.z.string().nullable().optional(),
+  createdAt: import_zod2.z.string(),
+  updatedAt: import_zod2.z.string()
+}).passthrough();
+var skillRegistryVersionItemSchema = import_zod2.z.object({
+  jobId: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  createdAt: import_zod2.z.string(),
+  verified: import_zod2.z.boolean().optional()
+}).passthrough();
+var skillRegistryVersionsResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  items: import_zod2.z.array(skillRegistryVersionItemSchema)
+}).passthrough();
+var skillRegistryMineItemSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  latestVersion: import_zod2.z.string(),
+  latestCreatedAt: import_zod2.z.string(),
+  verified: import_zod2.z.boolean().optional(),
+  iconHcs1: import_zod2.z.string().optional(),
+  versions: import_zod2.z.array(import_zod2.z.string())
+}).passthrough();
+var skillRegistryMineResponseSchema = import_zod2.z.object({
+  items: import_zod2.z.array(skillRegistryMineItemSchema)
+}).passthrough();
+var skillRegistryMyListResponseSchema = import_zod2.z.object({
+  owned: skillRegistryMineResponseSchema,
+  upvoted: skillRegistryListResponseSchema
+}).passthrough();
+var skillRegistryConfigResponseSchema = import_zod2.z.object({
+  enabled: import_zod2.z.boolean(),
+  directoryTopicId: import_zod2.z.string().nullable().optional(),
+  maxFiles: import_zod2.z.number().int().nullable().optional(),
+  maxTotalSizeBytes: import_zod2.z.number().int().nullable().optional(),
+  allowedMimeTypes: import_zod2.z.array(import_zod2.z.string()).nullable().optional(),
+  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]).nullable().optional(),
+  publisher: import_zod2.z.object({
+    cliPackageUrl: import_zod2.z.string(),
+    cliCommand: import_zod2.z.string(),
+    actionMarketplaceUrl: import_zod2.z.string(),
+    repositoryUrl: import_zod2.z.string(),
+    guideUrl: import_zod2.z.string().nullable().optional(),
+    docsUrl: import_zod2.z.string().nullable().optional(),
+    submitUrl: import_zod2.z.string().nullable().optional(),
+    skillsIndexUrl: import_zod2.z.string().nullable().optional(),
+    quickstartCommands: import_zod2.z.array(
+      import_zod2.z.object({
+        id: import_zod2.z.string(),
+        label: import_zod2.z.string(),
+        description: import_zod2.z.string(),
+        command: import_zod2.z.string(),
+        href: import_zod2.z.string().nullable().optional()
+      }).passthrough()
+    ).optional().default([]),
+    templatePresets: import_zod2.z.array(
+      import_zod2.z.object({
+        presetId: import_zod2.z.string(),
+        label: import_zod2.z.string(),
+        description: import_zod2.z.string(),
+        recommendedFor: import_zod2.z.string(),
+        command: import_zod2.z.string()
+      }).passthrough()
+    ).optional().default([])
+  }).nullable().optional()
+}).passthrough();
+var skillRegistryOwnershipResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  exists: import_zod2.z.boolean(),
+  isOwner: import_zod2.z.boolean()
+}).passthrough();
+var skillRegistryVoteStatusResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  upvotes: import_zod2.z.number().int(),
+  hasUpvoted: import_zod2.z.boolean()
 }).passthrough();
 var skillTrustTierSchema = import_zod2.z.enum([
-  "unpublished",
   "unclaimed",
   "validated",
   "published",
   "verified",
   "hardened"
 ]);
-var skillStatusDefaultVerificationSignals = {
-  publisherBound: false,
-  domainProof: false,
-  verifiedDomain: false,
-  previewValidated: false
-};
-var skillStatusDefaultProvenanceSignals = {
-  repoCommitIntegrity: false,
-  manifestIntegrity: false,
-  canonicalRelease: false,
-  previewAvailable: false,
-  previewAuthoritative: false
-};
-var skillStatusChecksSchema = import_zod2.z.object({
-  repoCommitIntegrity: import_zod2.z.boolean(),
-  manifestIntegrity: import_zod2.z.boolean(),
-  domainProof: import_zod2.z.boolean()
-}).passthrough();
 var skillStatusNextStepSchema = import_zod2.z.object({
   kind: import_zod2.z.enum([
     "setup_validate",
@@ -1411,8 +1664,8 @@ var skillStatusNextStepSchema = import_zod2.z.object({
     "verify_domain",
     "harden_workflow",
     "share_status"
-  ]).optional(),
-  priority: import_zod2.z.number().int().optional(),
+  ]),
+  priority: import_zod2.z.number().int(),
   id: import_zod2.z.string(),
   label: import_zod2.z.string(),
   description: import_zod2.z.string(),
@@ -1478,6 +1731,11 @@ var skillStatusPreviewMetadataSchema = import_zod2.z.object({
   expiresAt: import_zod2.z.string(),
   statusUrl: import_zod2.z.string()
 }).passthrough();
+var skillStatusChecksSchema = import_zod2.z.object({
+  repoCommitIntegrity: import_zod2.z.boolean(),
+  manifestIntegrity: import_zod2.z.boolean(),
+  domainProof: import_zod2.z.boolean()
+}).passthrough();
 var skillStatusVerificationSignalsSchema = import_zod2.z.object({
   publisherBound: import_zod2.z.boolean(),
   domainProof: import_zod2.z.boolean(),
@@ -1491,20 +1749,6 @@ var skillStatusProvenanceSignalsSchema = import_zod2.z.object({
   previewAvailable: import_zod2.z.boolean(),
   previewAuthoritative: import_zod2.z.boolean()
 }).passthrough();
-var skillBadgeMetricSchema = import_zod2.z.enum([
-  "version",
-  "version_verification",
-  "status",
-  "verification",
-  "repo_commit",
-  "manifest",
-  "domain",
-  "trust",
-  "tier",
-  "safety",
-  "upvotes",
-  "updated"
-]);
 var skillStatusResponseSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   version: import_zod2.z.string().nullable(),
@@ -1514,16 +1758,44 @@ var skillStatusResponseSchema = import_zod2.z.object({
   badgeMetric: skillBadgeMetricSchema,
   checks: skillStatusChecksSchema,
   nextSteps: import_zod2.z.array(skillStatusNextStepSchema),
-  verificationSignals: skillStatusVerificationSignalsSchema.default(
-    skillStatusDefaultVerificationSignals
-  ),
-  provenanceSignals: skillStatusProvenanceSignalsSchema.default(
-    skillStatusDefaultProvenanceSignals
-  ),
-  publisher: skillPublisherMetadataSchema.nullable().optional(),
+  verificationSignals: skillStatusVerificationSignalsSchema,
+  provenanceSignals: skillStatusProvenanceSignalsSchema,
+  publisher: skillRegistryConfigResponseSchema.shape.publisher,
   preview: skillStatusPreviewMetadataSchema.nullable().optional(),
   statusUrl: import_zod2.z.string().nullable().optional()
 }).passthrough();
+var skillQuotePreviewRangeSchema = import_zod2.z.object({
+  min: import_zod2.z.number(),
+  max: import_zod2.z.number()
+}).passthrough();
+var skillQuotePreviewResponseSchema = import_zod2.z.object({
+  estimatedCredits: skillQuotePreviewRangeSchema,
+  estimatedHbar: skillQuotePreviewRangeSchema,
+  pricingVersion: import_zod2.z.string(),
+  assumptions: import_zod2.z.array(import_zod2.z.string()),
+  purchaseUrl: import_zod2.z.string().nullable(),
+  publishUrl: import_zod2.z.string().nullable(),
+  verificationUrl: import_zod2.z.string().nullable()
+}).passthrough();
+var skillConversionSignalsResponseSchema = import_zod2.z.object({
+  repoUrl: import_zod2.z.string(),
+  skillDir: import_zod2.z.string(),
+  trustTier: skillTrustTierSchema,
+  actionInstalled: import_zod2.z.boolean(),
+  previewUploaded: import_zod2.z.boolean(),
+  previewId: import_zod2.z.string().nullable(),
+  lastValidateSuccessAt: import_zod2.z.string().nullable(),
+  stalePreviewAgeDays: import_zod2.z.number().nullable(),
+  published: import_zod2.z.boolean(),
+  verified: import_zod2.z.boolean(),
+  publishReady: import_zod2.z.boolean(),
+  publishBlockedByMissingAuth: import_zod2.z.boolean(),
+  statusUrl: import_zod2.z.string().nullable(),
+  purchaseUrl: import_zod2.z.string().nullable(),
+  publishUrl: import_zod2.z.string().nullable(),
+  verificationUrl: import_zod2.z.string().nullable(),
+  nextSteps: import_zod2.z.array(skillStatusNextStepSchema)
+}).passthrough();
 var skillInstallArtifactDescriptorSchema = import_zod2.z.object({
   url: import_zod2.z.string(),
   pointer: import_zod2.z.string().nullable(),
@@ -1559,146 +1831,20 @@ var skillInstallResponseSchema = import_zod2.z.object({
   version: import_zod2.z.string(),
   skillRef: import_zod2.z.string(),
   network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]),
-  detailUrl: import_zod2.z.string().nullable(),
-  artifacts: import_zod2.z.object({
-    skillMd: skillInstallArtifactDescriptorSchema,
-    manifest: skillInstallArtifactDescriptorSchema
-  }).passthrough(),
-  resolvers: import_zod2.z.object({
-    pinned: skillInstallResolverDescriptorSchema,
-    latest: skillInstallResolverDescriptorSchema
-  }).passthrough(),
-  share: skillInstallShareDescriptorSchema,
-  snippets: skillInstallSnippetSetSchema
-}).passthrough();
-var skillInstallCopyTelemetryResponseSchema = import_zod2.z.object({
-  accepted: import_zod2.z.boolean()
-}).passthrough();
-var skillBadgeStyleSchema = import_zod2.z.enum([
-  "flat",
-  "flat-square",
-  "for-the-badge",
-  "plastic",
-  "social"
-]);
-var skillBadgeResponseSchema = import_zod2.z.object({
-  schemaVersion: import_zod2.z.number().int(),
-  label: import_zod2.z.string(),
-  message: import_zod2.z.string(),
-  color: import_zod2.z.string(),
-  style: skillBadgeStyleSchema.optional(),
-  isError: import_zod2.z.boolean().optional(),
-  cacheSeconds: import_zod2.z.number().int().optional()
-}).passthrough();
-var skillRegistryTagsResponseSchema = import_zod2.z.object({
-  tags: import_zod2.z.array(import_zod2.z.string())
-}).passthrough();
-var skillRegistryCategoriesResponseSchema = import_zod2.z.object({
-  categories: import_zod2.z.array(import_zod2.z.string())
-}).passthrough();
-var skillResolverManifestResponseSchema = import_zod2.z.record(jsonValueSchema);
-var skillRegistryQuoteFileBreakdownSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  mimeType: import_zod2.z.string(),
-  estimatedCostHbar: import_zod2.z.number()
-}).passthrough();
-var skillRegistryQuoteResponseSchema = import_zod2.z.object({
-  quoteId: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  version: import_zod2.z.string(),
-  directoryTopicId: import_zod2.z.string(),
-  estimatedCostHbar: import_zod2.z.number(),
-  credits: import_zod2.z.number(),
-  usdCents: import_zod2.z.number(),
-  expiresAt: import_zod2.z.string(),
-  files: import_zod2.z.array(skillRegistryQuoteFileBreakdownSchema)
-}).passthrough();
-var skillRegistryJobStatusSchema = import_zod2.z.union([
-  import_zod2.z.literal("pending"),
-  import_zod2.z.literal("in_progress"),
-  import_zod2.z.literal("completed"),
-  import_zod2.z.literal("failed")
-]);
-var skillRegistryPublishResponseSchema = import_zod2.z.object({
-  jobId: import_zod2.z.string(),
-  status: skillRegistryJobStatusSchema,
-  credits: import_zod2.z.number().nullable().optional(),
-  usdCents: import_zod2.z.number().nullable().optional(),
-  quoteId: import_zod2.z.string().nullable().optional(),
-  createdAt: import_zod2.z.string(),
-  updatedAt: import_zod2.z.string(),
-  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")])
-}).passthrough();
-var skillRegistryJobStatusResponseSchema = import_zod2.z.object({
-  jobId: import_zod2.z.string(),
-  status: skillRegistryJobStatusSchema,
-  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]),
-  name: import_zod2.z.string(),
-  version: import_zod2.z.string(),
-  directoryTopicId: import_zod2.z.string(),
-  skillUid: import_zod2.z.number().int().nullable().optional(),
-  directorySequenceNumber: import_zod2.z.number().int().nullable().optional(),
-  versionRegistryTopicId: import_zod2.z.string().nullable().optional(),
-  packageTopicId: import_zod2.z.string().nullable().optional(),
-  manifestHrl: import_zod2.z.string().nullable().optional(),
-  skillJsonHrl: import_zod2.z.string().nullable().optional(),
-  iconHcs1: import_zod2.z.string().nullable().optional(),
-  tags: import_zod2.z.array(import_zod2.z.string()).nullable().optional(),
-  category: import_zod2.z.string().nullable().optional(),
-  files: import_zod2.z.array(skillRegistryFileDescriptorSchema).nullable().optional(),
-  quoteCredits: import_zod2.z.number().nullable().optional(),
-  quoteUsdCents: import_zod2.z.number().nullable().optional(),
-  safety: skillSafetySummarySchema.nullable().optional(),
-  reservationId: import_zod2.z.string().nullable().optional(),
-  totalCostHbar: import_zod2.z.number().nullable().optional(),
-  totalCostCredits: import_zod2.z.number().nullable().optional(),
-  failureReason: import_zod2.z.string().nullable().optional(),
-  createdAt: import_zod2.z.string(),
-  updatedAt: import_zod2.z.string()
-}).passthrough();
-var skillRegistryVersionItemSchema = import_zod2.z.object({
-  jobId: import_zod2.z.string(),
-  version: import_zod2.z.string(),
-  createdAt: import_zod2.z.string(),
-  verified: import_zod2.z.boolean().optional()
-}).passthrough();
-var skillRegistryVersionsResponseSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  items: import_zod2.z.array(skillRegistryVersionItemSchema)
-}).passthrough();
-var skillRegistryMineItemSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  latestVersion: import_zod2.z.string(),
-  latestCreatedAt: import_zod2.z.string(),
-  verified: import_zod2.z.boolean().optional(),
-  iconHcs1: import_zod2.z.string().optional(),
-  versions: import_zod2.z.array(import_zod2.z.string())
-}).passthrough();
-var skillRegistryMineResponseSchema = import_zod2.z.object({
-  items: import_zod2.z.array(skillRegistryMineItemSchema)
-}).passthrough();
-var skillRegistryMyListResponseSchema = import_zod2.z.object({
-  owned: skillRegistryMineResponseSchema,
-  upvoted: skillRegistryListResponseSchema
-}).passthrough();
-var skillRegistryConfigResponseSchema = import_zod2.z.object({
-  enabled: import_zod2.z.boolean(),
-  directoryTopicId: import_zod2.z.string().nullable().optional(),
-  maxFiles: import_zod2.z.number().int().nullable().optional(),
-  maxTotalSizeBytes: import_zod2.z.number().int().nullable().optional(),
-  allowedMimeTypes: import_zod2.z.array(import_zod2.z.string()).nullable().optional(),
-  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]).nullable().optional(),
-  publisher: skillPublisherMetadataSchema.nullable().optional()
-}).passthrough();
-var skillRegistryOwnershipResponseSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  exists: import_zod2.z.boolean(),
-  isOwner: import_zod2.z.boolean()
+  detailUrl: import_zod2.z.string().nullable(),
+  artifacts: import_zod2.z.object({
+    skillMd: skillInstallArtifactDescriptorSchema,
+    manifest: skillInstallArtifactDescriptorSchema
+  }).passthrough(),
+  resolvers: import_zod2.z.object({
+    pinned: skillInstallResolverDescriptorSchema,
+    latest: skillInstallResolverDescriptorSchema
+  }).passthrough(),
+  share: skillInstallShareDescriptorSchema,
+  snippets: skillInstallSnippetSetSchema
 }).passthrough();
-var skillRegistryVoteStatusResponseSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  upvotes: import_zod2.z.number().int(),
-  hasUpvoted: import_zod2.z.boolean()
+var skillInstallCopyTelemetryResponseSchema = import_zod2.z.object({
+  accepted: import_zod2.z.boolean()
 }).passthrough();
 var skillVerificationTierSchema = import_zod2.z.enum(["basic", "express"]);
 var skillVerificationStatusSchema = import_zod2.z.enum([
@@ -2798,9 +2944,16 @@ var isBrowser = typeof window !== "undefined" && typeof window.document !== "und
 var import_meta = {};
 var nodeRequire;
 var isNodeRuntime = () => typeof process !== "undefined" && Boolean(process.versions?.node);
+function resolveBuiltinModuleLoader() {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process.getBuiltinModule;
+}
 function getNodeRequireSync() {
   try {
-    const moduleNamespace = process.getBuiltinModule?.("module");
+    const builtinModuleLoader = resolveBuiltinModuleLoader();
+    const moduleNamespace = builtinModuleLoader?.("module");
     if (typeof moduleNamespace?.createRequire === "function") {
       const requireFromModule = moduleNamespace.createRequire(import_meta.url);
       if (typeof requireFromModule.resolve === "function") {
@@ -3200,6 +3353,61 @@ async function adapterRegistrySubmissionStatus(client, submissionId) {
 }
 
 // ../../src/services/registry-broker/client/credits.ts
+async function getCreditsBalance(client, params = {}) {
+  const query = new URLSearchParams();
+  const normalizedAccountId = params.accountId?.trim();
+  if (normalizedAccountId) {
+    query.set("accountId", normalizedAccountId);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/credits/balance${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    creditBalanceResponseSchema,
+    "credit balance response"
+  );
+}
+async function getCreditProviders(client) {
+  const raw = await client.requestJson("/credits/providers", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    creditProvidersResponseSchema,
+    "credit providers response"
+  );
+}
+async function createHbarPurchaseIntent(client, payload) {
+  const body = {};
+  const normalizedAccountId = payload.accountId?.trim();
+  if (normalizedAccountId) {
+    body.accountId = normalizedAccountId;
+  }
+  if (payload.credits !== void 0) {
+    body.credits = payload.credits;
+  }
+  if (payload.hbarAmount !== void 0) {
+    body.hbarAmount = payload.hbarAmount;
+  }
+  if (payload.memo?.trim()) {
+    body.memo = payload.memo.trim();
+  }
+  const raw = await client.requestJson(
+    "/credits/payments/hbar/intent",
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    hbarPurchaseIntentResponseSchema,
+    "hbar purchase intent response"
+  );
+}
 async function loadX402Dependencies(client) {
   const [{ default: axios }, x402Axios, x402Types] = await Promise.all([
     import("axios"),
@@ -3727,6 +3935,97 @@ async function registerOwnedMoltbookAgent(client, uaid, request) {
   );
 }
 
+// ../../src/services/registry-broker/client/guard.ts
+async function getGuardSession(client) {
+  const raw = await client.requestJson("/guard/auth/session", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardSessionResponseSchema,
+    "guard session response"
+  );
+}
+async function getGuardEntitlements(client) {
+  const raw = await client.requestJson("/guard/entitlements", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardSessionResponseSchema,
+    "guard entitlements response"
+  );
+}
+async function getGuardBillingBalance(client) {
+  const raw = await client.requestJson("/guard/billing/balance", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardBalanceResponseSchema,
+    "guard billing balance response"
+  );
+}
+async function getGuardTrustByHash(client, sha256) {
+  const normalizedHash = sha256.trim();
+  if (!normalizedHash) {
+    throw new Error("sha256 is required");
+  }
+  const raw = await client.requestJson(
+    `/guard/trust/by-hash/${encodeURIComponent(normalizedHash)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardTrustByHashResponseSchema,
+    "guard trust by hash response"
+  );
+}
+async function resolveGuardTrust(client, query) {
+  const params = new URLSearchParams();
+  if (query.ecosystem?.trim()) {
+    params.set("ecosystem", query.ecosystem.trim());
+  }
+  if (query.name?.trim()) {
+    params.set("name", query.name.trim());
+  }
+  if (query.version?.trim()) {
+    params.set("version", query.version.trim());
+  }
+  const suffix = params.size > 0 ? `?${params.toString()}` : "";
+  const raw = await client.requestJson(
+    `/guard/trust/resolve${suffix}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardTrustResolveResponseSchema,
+    "guard trust resolve response"
+  );
+}
+async function getGuardRevocations(client) {
+  const raw = await client.requestJson("/guard/revocations", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardRevocationResponseSchema,
+    "guard revocations response"
+  );
+}
+async function syncGuardReceipts(client, payload) {
+  const raw = await client.requestJson("/guard/receipts/sync", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardReceiptSyncResponseSchema,
+    "guard receipt sync response"
+  );
+}
+
 // ../../src/services/registry-broker/client/ledger-auth.ts
 var import_buffer3 = require("buffer");
 
@@ -4298,6 +4597,13 @@ async function facets(client, adapter) {
 }
 
 // ../../src/services/registry-broker/client/skills.ts
+function requireTrimmedString(value, fieldName) {
+  const normalizedValue = value.trim();
+  if (!normalizedValue) {
+    throw new Error(`${fieldName} is required`);
+  }
+  return normalizedValue;
+}
 async function skillsConfig(client) {
   const raw = await client.requestJson("/skills/config", {
     method: "GET"
@@ -4308,57 +4614,6 @@ async function skillsConfig(client) {
     "skill registry config response"
   );
 }
-async function getSkillStatus(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
-  const query = new URLSearchParams();
-  query.set("name", normalizedName);
-  if (params.version?.trim()) {
-    query.set("version", params.version.trim());
-  }
-  const raw = await client.requestJson(
-    `/skills/status?${query.toString()}`,
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    skillStatusResponseSchema,
-    "skill status response"
-  );
-}
-function buildRepoPreviewQuery(params) {
-  const repo = params.repo.trim();
-  const skillDir = params.skillDir.trim();
-  if (!repo) {
-    throw new Error("repo is required");
-  }
-  if (!skillDir) {
-    throw new Error("skillDir is required");
-  }
-  const query = new URLSearchParams();
-  query.set("repo", repo);
-  query.set("skillDir", skillDir);
-  if (params.ref?.trim()) {
-    query.set("ref", params.ref.trim());
-  }
-  return query.toString();
-}
-async function getSkillStatusByRepo(client, params) {
-  const query = buildRepoPreviewQuery(params);
-  const raw = await client.requestJson(
-    `/skills/status/by-repo?${query}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    skillStatusResponseSchema,
-    "skill status response"
-  );
-}
 async function listSkills(client, params = {}) {
   const query = new URLSearchParams();
   if (params.name) {
@@ -4408,10 +4663,7 @@ async function listSkills(client, params = {}) {
   );
 }
 async function getSkillSecurityBreakdown(client, params) {
-  const normalizedJobId = params.jobId.trim();
-  if (!normalizedJobId) {
-    throw new Error("jobId is required");
-  }
+  const normalizedJobId = requireTrimmedString(params.jobId, "jobId");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedJobId)}/security-breakdown`,
     { method: "GET" }
@@ -4464,10 +4716,7 @@ async function getSkillsCatalog(client, params = {}) {
   );
 }
 async function listSkillVersions(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4528,6 +4777,18 @@ async function quoteSkillPublish(client, payload) {
     "skill registry quote response"
   );
 }
+async function quoteSkillPublishPreview(client, payload) {
+  const raw = await client.requestJson("/skills/quote-preview", {
+    method: "POST",
+    body: payload,
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillQuotePreviewResponseSchema,
+    "skill quote preview response"
+  );
+}
 async function publishSkill(client, payload) {
   const raw = await client.requestJson("/skills/publish", {
     method: "POST",
@@ -4541,10 +4802,7 @@ async function publishSkill(client, payload) {
   );
 }
 async function getSkillPublishJob(client, jobId, params = {}) {
-  const normalized = jobId.trim();
-  if (!normalized) {
-    throw new Error("jobId is required");
-  }
+  const normalized = requireTrimmedString(jobId, "jobId");
   const query = new URLSearchParams();
   if (params.accountId) {
     query.set("accountId", params.accountId);
@@ -4561,10 +4819,7 @@ async function getSkillPublishJob(client, jobId, params = {}) {
   );
 }
 async function getSkillOwnership(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.accountId) {
@@ -4583,10 +4838,7 @@ async function getSkillOwnership(client, params) {
   );
 }
 async function getRecommendedSkillVersion(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4600,14 +4852,8 @@ async function getRecommendedSkillVersion(client, params) {
   );
 }
 async function setRecommendedSkillVersion(client, payload) {
-  const normalizedName = payload.name.trim();
-  const normalizedVersion = payload.version.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
-  if (!normalizedVersion) {
-    throw new Error("version is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
+  const normalizedVersion = requireTrimmedString(payload.version, "version");
   const raw = await client.requestJson("/skills/recommended", {
     method: "POST",
     body: {
@@ -4623,10 +4869,7 @@ async function setRecommendedSkillVersion(client, payload) {
   );
 }
 async function getSkillDeprecations(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4640,15 +4883,9 @@ async function getSkillDeprecations(client, params) {
   );
 }
 async function setSkillDeprecation(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const version = payload.version?.trim();
-  const reason = payload.reason.trim();
-  if (!reason) {
-    throw new Error("reason is required");
-  }
+  const reason = requireTrimmedString(payload.reason, "reason");
   const replacementRef = payload.replacementRef?.trim();
   const raw = await client.requestJson("/skills/deprecate", {
     method: "POST",
@@ -4667,10 +4904,7 @@ async function setSkillDeprecation(client, payload) {
   );
 }
 async function getSkillBadge(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.metric) {
@@ -4692,11 +4926,63 @@ async function getSkillBadge(client, params) {
     "skill badge response"
   );
 }
-async function uploadSkillPreviewFromGithubOidc(client, payload) {
-  const token = payload.token.trim();
-  if (!token) {
-    throw new Error("token is required");
+async function getSkillStatus(client, params) {
+  const normalizedName = requireTrimmedString(params.name, "name");
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version?.trim()) {
+    query.set("version", params.version.trim());
+  }
+  const raw = await client.requestJson(
+    `/skills/status?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
+}
+async function getSkillStatusByRepo(client, params) {
+  const repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
+  }
+  const raw = await client.requestJson(
+    `/skills/status/by-repo?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
+}
+async function getSkillConversionSignalsByRepo(client, params) {
+  const repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
   }
+  const raw = await client.requestJson(
+    `/skills/conversion-signals/by-repo?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillConversionSignalsResponseSchema,
+    "skill conversion signals response"
+  );
+}
+async function uploadSkillPreviewFromGithubOidc(client, payload) {
+  const token = requireTrimmedString(payload.token, "token");
   const raw = await client.requestJson(
     "/skills/preview/github-oidc",
     {
@@ -4715,10 +5001,7 @@ async function uploadSkillPreviewFromGithubOidc(client, payload) {
   );
 }
 async function getSkillPreview(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.version?.trim()) {
@@ -4735,9 +5018,16 @@ async function getSkillPreview(client, params) {
   );
 }
 async function getSkillPreviewByRepo(client, params) {
-  const query = buildRepoPreviewQuery(params);
+  const repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
+  }
   const raw = await client.requestJson(
-    `/skills/preview/by-repo?${query}`,
+    `/skills/preview/by-repo?${query.toString()}`,
     { method: "GET" }
   );
   return client.parseWithSchema(
@@ -4747,10 +5037,7 @@ async function getSkillPreviewByRepo(client, params) {
   );
 }
 async function getSkillPreviewById(client, previewId) {
-  const normalizedPreviewId = previewId.trim();
-  if (!normalizedPreviewId) {
-    throw new Error("previewId is required");
-  }
+  const normalizedPreviewId = requireTrimmedString(previewId, "previewId");
   const raw = await client.requestJson(
     `/skills/preview/${encodeURIComponent(normalizedPreviewId)}`,
     { method: "GET" }
@@ -4762,10 +5049,7 @@ async function getSkillPreviewById(client, previewId) {
   );
 }
 async function getSkillInstall(client, skillRef) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/install`,
     { method: "GET" }
@@ -4777,10 +5061,7 @@ async function getSkillInstall(client, skillRef) {
   );
 }
 async function recordSkillInstallCopy(client, skillRef, payload = {}) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/telemetry/install-copy`,
     {
@@ -4816,10 +5097,7 @@ async function listSkillCategories(client) {
   );
 }
 async function resolveSkillMarkdown(client, skillRef) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const response = await client.request(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/SKILL.md`,
     {
@@ -4832,10 +5110,7 @@ async function resolveSkillMarkdown(client, skillRef) {
   return response.text();
 }
 async function resolveSkillManifest(client, skillRef) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/manifest`,
     {
@@ -4849,10 +5124,7 @@ async function resolveSkillManifest(client, skillRef) {
   );
 }
 async function getSkillVoteStatus(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4866,10 +5138,7 @@ async function getSkillVoteStatus(client, params) {
   );
 }
 async function setSkillVote(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const raw = await client.requestJson("/skills/vote", {
     method: "POST",
     body: { name: normalizedName, upvoted: payload.upvoted },
@@ -4882,10 +5151,7 @@ async function setSkillVote(client, payload) {
   );
 }
 async function requestSkillVerification(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const raw = await client.requestJson(
     "/skills/verification/request",
     {
@@ -4905,10 +5171,7 @@ async function requestSkillVerification(client, payload) {
   );
 }
 async function getSkillVerificationStatus(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.version) {
@@ -4925,10 +5188,7 @@ async function getSkillVerificationStatus(client, params) {
   );
 }
 async function createSkillDomainProofChallenge(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const raw = await client.requestJson(
     "/skills/verification/domain/challenge",
     {
@@ -4948,14 +5208,11 @@ async function createSkillDomainProofChallenge(client, payload) {
   );
 }
 async function verifySkillDomainProof(client, payload) {
-  const normalizedName = payload.name.trim();
-  const challengeToken = payload.challengeToken.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
-  if (!challengeToken) {
-    throw new Error("challengeToken is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
+  const challengeToken = requireTrimmedString(
+    payload.challengeToken,
+    "challengeToken"
+  );
   const raw = await client.requestJson(
     "/skills/verification/domain/verify",
     {
@@ -5314,15 +5571,9 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async skillsConfig() {
     return skillsConfig(this);
   }
-  async getSkillStatus(params) {
-    return getSkillStatus(this, params);
-  }
   async listSkills(options) {
     return listSkills(this, options);
   }
-  async getSkillSecurityBreakdown(params) {
-    return getSkillSecurityBreakdown(this, params);
-  }
   async getSkillsCatalog(options) {
     return getSkillsCatalog(this, options);
   }
@@ -5338,6 +5589,9 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async quoteSkillPublish(payload) {
     return quoteSkillPublish(this, payload);
   }
+  async quoteSkillPublishPreview(payload) {
+    return quoteSkillPublishPreview(this, payload);
+  }
   async publishSkill(payload) {
     return publishSkill(this, payload);
   }
@@ -5362,9 +5616,18 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async getSkillBadge(params) {
     return getSkillBadge(this, params);
   }
+  async getSkillStatus(params) {
+    return getSkillStatus(this, params);
+  }
+  async getSkillSecurityBreakdown(params) {
+    return getSkillSecurityBreakdown(this, params);
+  }
   async getSkillStatusByRepo(params) {
     return getSkillStatusByRepo(this, params);
   }
+  async getSkillConversionSignalsByRepo(params) {
+    return getSkillConversionSignalsByRepo(this, params);
+  }
   async uploadSkillPreviewFromGithubOidc(payload) {
     return uploadSkillPreviewFromGithubOidc(this, payload);
   }
@@ -5563,6 +5826,36 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async dashboardStats() {
     return dashboardStats(this);
   }
+  async getCreditsBalance(params = {}) {
+    return getCreditsBalance(this, params);
+  }
+  async getCreditProviders() {
+    return getCreditProviders(this);
+  }
+  async getGuardSession() {
+    return getGuardSession(this);
+  }
+  async getGuardEntitlements() {
+    return getGuardEntitlements(this);
+  }
+  async getGuardBillingBalance() {
+    return getGuardBillingBalance(this);
+  }
+  async getGuardTrustByHash(sha256) {
+    return getGuardTrustByHash(this, sha256);
+  }
+  async resolveGuardTrust(query) {
+    return resolveGuardTrust(this, query);
+  }
+  async getGuardRevocations() {
+    return getGuardRevocations(this);
+  }
+  async syncGuardReceipts(payload) {
+    return syncGuardReceipts(this, payload);
+  }
+  async createHbarPurchaseIntent(payload) {
+    return createHbarPurchaseIntent(this, payload);
+  }
   async purchaseCreditsWithHbar(params) {
     return purchaseCreditsWithHbar(this, params);
   }
@@ -5764,9 +6057,20 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
     }
     return nodeCrypto;
   }
+  getSecureRandomBytes(size, feature) {
+    const webCrypto = globalThis.crypto;
+    if (webCrypto && typeof webCrypto.getRandomValues === "function") {
+      const bytes = new Uint8Array(size);
+      webCrypto.getRandomValues(bytes);
+      return bytes;
+    }
+    return this.getNodeCrypto(feature).randomBytes(size);
+  }
   createEphemeralKeyPair() {
-    const { randomBytes } = this.getNodeCrypto("generateEphemeralKeyPair");
-    const privateKeyBytes = randomBytes(32);
+    const privateKeyBytes = this.getSecureRandomBytes(
+      32,
+      "generateEphemeralKeyPair"
+    );
     const publicKey = import_secp256k12.secp256k1.getPublicKey(privateKeyBytes, true);
     return {
       privateKey: import_buffer4.Buffer.from(privateKeyBytes).toString("hex"),