@hol-org/rb-client 0.1.175 → 0.1.177

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();
@@ -1291,14 +1275,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,52 +1328,17 @@ 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()
-}).passthrough();
-var skillPublisherTemplatePresetSchema = 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();
-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)
-}).passthrough();
-var skillTrustTierSchema = import_zod2.z.enum([
-  "unpublished",
-  "published",
-  "verified",
-  "hardened"
-]);
-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({
-  id: import_zod2.z.string(),
-  label: import_zod2.z.string(),
-  description: import_zod2.z.string(),
-  href: import_zod2.z.string().nullable().optional(),
-  command: import_zod2.z.string().nullable().optional()
+var skillSecurityBreakdownResponseSchema = import_zod2.z.object({
+  jobId: import_zod2.z.string(),
+  score: import_zod2.z.number().nullable().optional(),
+  findings: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+  summary: import_zod2.z.unknown().optional(),
+  generatedAt: import_zod2.z.string().nullable().optional(),
+  scannerVersion: import_zod2.z.string().nullable().optional()
 }).passthrough();
 var skillBadgeMetricSchema = import_zod2.z.enum([
   "version",
+  "version_verification",
   "status",
   "verification",
   "repo_commit",
@@ -1409,17 +1350,6 @@ var skillBadgeMetricSchema = import_zod2.z.enum([
   "upvotes",
   "updated"
 ]);
-var skillStatusResponseSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  version: import_zod2.z.string().nullable(),
-  published: import_zod2.z.boolean(),
-  verifiedDomain: import_zod2.z.boolean(),
-  trustTier: skillTrustTierSchema,
-  badgeMetric: skillBadgeMetricSchema,
-  checks: skillStatusChecksSchema,
-  nextSteps: import_zod2.z.array(skillStatusNextStepSchema),
-  publisher: skillPublisherMetadataSchema.nullable().optional()
-}).passthrough();
 var skillBadgeStyleSchema = import_zod2.z.enum([
   "flat",
   "flat-square",
@@ -1534,7 +1464,34 @@ var skillRegistryConfigResponseSchema = import_zod2.z.object({
   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()
+  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(),
@@ -1546,6 +1503,202 @@ var skillRegistryVoteStatusResponseSchema = import_zod2.z.object({
   upvotes: import_zod2.z.number().int(),
   hasUpvoted: import_zod2.z.boolean()
 }).passthrough();
+var skillTrustTierSchema = import_zod2.z.enum([
+  "unclaimed",
+  "validated",
+  "published",
+  "verified",
+  "hardened"
+]);
+var skillStatusNextStepSchema = import_zod2.z.object({
+  kind: import_zod2.z.enum([
+    "setup_validate",
+    "publish_first_release",
+    "verify_domain",
+    "harden_workflow",
+    "share_status"
+  ]),
+  priority: import_zod2.z.number().int(),
+  id: import_zod2.z.string(),
+  label: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  url: import_zod2.z.string().nullable().optional(),
+  href: import_zod2.z.string().nullable().optional(),
+  command: import_zod2.z.string().nullable().optional()
+}).passthrough();
+var skillPreviewSuggestedNextStepSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  label: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  command: import_zod2.z.string().optional(),
+  href: import_zod2.z.string().optional()
+}).passthrough();
+var skillPreviewReportSchema = import_zod2.z.object({
+  schema_version: import_zod2.z.literal("skill-preview.v1"),
+  tool_version: import_zod2.z.string(),
+  preview_id: import_zod2.z.string(),
+  repo_url: import_zod2.z.string(),
+  repo_owner: import_zod2.z.string(),
+  repo_name: import_zod2.z.string(),
+  default_branch: import_zod2.z.string(),
+  commit_sha: import_zod2.z.string(),
+  ref: import_zod2.z.string(),
+  event_name: import_zod2.z.string(),
+  workflow_run_url: import_zod2.z.string(),
+  skill_dir: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  validation_status: import_zod2.z.literal("passed"),
+  findings: import_zod2.z.array(import_zod2.z.unknown()),
+  package_summary: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
+  suggested_next_steps: import_zod2.z.array(skillPreviewSuggestedNextStepSchema),
+  generated_at: import_zod2.z.string()
+}).passthrough();
+var skillPreviewRecordSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  previewId: import_zod2.z.string(),
+  source: import_zod2.z.literal("github-oidc"),
+  report: skillPreviewReportSchema,
+  generatedAt: import_zod2.z.string(),
+  expiresAt: import_zod2.z.string(),
+  statusUrl: import_zod2.z.string(),
+  authoritative: import_zod2.z.boolean()
+}).passthrough();
+var skillPreviewLookupResponseSchema = import_zod2.z.object({
+  found: import_zod2.z.boolean(),
+  authoritative: import_zod2.z.boolean(),
+  preview: skillPreviewRecordSchema.nullable(),
+  statusUrl: import_zod2.z.string().nullable(),
+  expiresAt: import_zod2.z.string().nullable()
+}).passthrough();
+var skillStatusPreviewMetadataSchema = import_zod2.z.object({
+  previewId: import_zod2.z.string(),
+  repoUrl: import_zod2.z.string(),
+  repoOwner: import_zod2.z.string(),
+  repoName: import_zod2.z.string(),
+  commitSha: import_zod2.z.string(),
+  ref: import_zod2.z.string(),
+  eventName: import_zod2.z.string(),
+  skillDir: import_zod2.z.string(),
+  generatedAt: import_zod2.z.string(),
+  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(),
+  verifiedDomain: import_zod2.z.boolean(),
+  previewValidated: import_zod2.z.boolean()
+}).passthrough();
+var skillStatusProvenanceSignalsSchema = import_zod2.z.object({
+  repoCommitIntegrity: import_zod2.z.boolean(),
+  manifestIntegrity: import_zod2.z.boolean(),
+  canonicalRelease: import_zod2.z.boolean(),
+  previewAvailable: import_zod2.z.boolean(),
+  previewAuthoritative: import_zod2.z.boolean()
+}).passthrough();
+var skillStatusResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string().nullable(),
+  published: import_zod2.z.boolean(),
+  verifiedDomain: import_zod2.z.boolean(),
+  trustTier: skillTrustTierSchema,
+  badgeMetric: skillBadgeMetricSchema,
+  checks: skillStatusChecksSchema,
+  nextSteps: import_zod2.z.array(skillStatusNextStepSchema),
+  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(),
+  sha256: import_zod2.z.string().nullable()
+}).passthrough();
+var skillInstallResolverDescriptorSchema = import_zod2.z.object({
+  skillRef: import_zod2.z.string(),
+  skillMdUrl: import_zod2.z.string(),
+  manifestUrl: import_zod2.z.string()
+}).passthrough();
+var skillInstallBadgeDescriptorSchema = import_zod2.z.object({
+  apiUrl: import_zod2.z.string(),
+  imageUrl: import_zod2.z.string(),
+  markdown: import_zod2.z.string(),
+  html: import_zod2.z.string()
+}).passthrough();
+var skillInstallShareDescriptorSchema = import_zod2.z.object({
+  canonicalUrl: import_zod2.z.string().nullable(),
+  latestUrl: import_zod2.z.string().nullable(),
+  markdownLink: import_zod2.z.string().nullable(),
+  htmlLink: import_zod2.z.string().nullable(),
+  badge: skillInstallBadgeDescriptorSchema.nullable()
+}).passthrough();
+var skillInstallSnippetSetSchema = import_zod2.z.object({
+  cli: import_zod2.z.string(),
+  claude: import_zod2.z.string(),
+  cursor: import_zod2.z.string(),
+  codex: import_zod2.z.string(),
+  openclaw: import_zod2.z.string()
+}).passthrough();
+var skillInstallResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  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 skillVerificationTierSchema = import_zod2.z.enum(["basic", "express"]);
 var skillVerificationStatusSchema = import_zod2.z.enum([
   "pending",
@@ -4154,28 +4307,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"
-  );
-}
 async function listSkills(client, params = {}) {
   const query = new URLSearchParams();
   if (params.name) {
@@ -4345,6 +4476,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",
@@ -4509,6 +4652,192 @@ async function getSkillBadge(client, params) {
     "skill badge 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"
+  );
+}
+async function getSkillStatusByRepo(client, 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());
+  }
+  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 = 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());
+  }
+  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 = payload.token.trim();
+  if (!token) {
+    throw new Error("token is required");
+  }
+  const raw = await client.requestJson(
+    "/skills/preview/github-oidc",
+    {
+      method: "POST",
+      body: payload.report,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
+      }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewRecordSchema,
+    "skill preview record response"
+  );
+}
+async function getSkillPreview(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/preview?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview response"
+  );
+}
+async function getSkillPreviewByRepo(client, 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());
+  }
+  const raw = await client.requestJson(
+    `/skills/preview/by-repo?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by repo response"
+  );
+}
+async function getSkillPreviewById(client, previewId) {
+  const normalizedPreviewId = previewId.trim();
+  if (!normalizedPreviewId) {
+    throw new Error("previewId is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/preview/${encodeURIComponent(normalizedPreviewId)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by id response"
+  );
+}
+async function getSkillInstall(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/install`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillInstallResponseSchema,
+    "skill install response"
+  );
+}
+async function recordSkillInstallCopy(client, skillRef, payload = {}) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/telemetry/install-copy`,
+    {
+      method: "POST",
+      body: payload,
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillInstallCopyTelemetryResponseSchema,
+    "skill install copy telemetry response"
+  );
+}
 async function listSkillTags(client) {
   const raw = await client.requestJson("/skills/tags", {
     method: "GET"
@@ -5028,15 +5357,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);
   }
@@ -5052,6 +5375,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);
   }
@@ -5076,6 +5402,36 @@ 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);
+  }
+  async getSkillPreview(params) {
+    return getSkillPreview(this, params);
+  }
+  async getSkillPreviewByRepo(params) {
+    return getSkillPreviewByRepo(this, params);
+  }
+  async getSkillPreviewById(previewId) {
+    return getSkillPreviewById(this, previewId);
+  }
+  async getSkillInstall(skillRef) {
+    return getSkillInstall(this, skillRef);
+  }
+  async recordSkillInstallCopy(skillRef, payload) {
+    return recordSkillInstallCopy(this, skillRef, payload);
+  }
   async listSkillTags() {
     return listSkillTags(this);
   }
@@ -5457,9 +5813,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"),