@buildinternet/releases-api-types 0.58.3 → 0.60.0

package/dist/schemas/listing.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+/**
+ * Public wire contract for the self-serve listing lane (#1947):
+ * POST /v1/listing/validate and POST /v1/listing/activate. This projection is
+ * deliberately independent of the internal materialization plan — it is the
+ * stable shape web/CLI consume while internals stay free to change.
+ */
+export const ListingValidateBodySchema = z.strictObject({
+    domain: z.string().min(1).max(255),
+});
+export const ListingActivateBodySchema = z.strictObject({
+    domain: z.string().min(1).max(255),
+    requestTracking: z.boolean().optional(),
+});
+export const ListingIssueSchema = z.strictObject({
+    path: z.string(),
+    message: z.string(),
+});
+/** One follow-up the owner takes after declaring `publish: "push"`. */
+export const ListingSetupStepSchema = z.strictObject({
+    id: z.enum(["verify", "token", "action"]),
+    title: z.string(),
+    detail: z.string(),
+});
+export const ListingLocationSchema = z.strictObject({
+    /** The declared locator value (feed URL, github ref, url, appstore id, file). */
+    locator: z.string(),
+    kind: z.enum(["feed", "github", "appstore", "url", "file", "push"]),
+    classification: z.enum(["tier1-live", "tier2-paused-review", "push-setup"]),
+    /** Plain-English "what this becomes" for the preview UI. */
+    becomes: z.string(),
+    /** Present when the locator is nested under a manifest product. */
+    productName: z.string().optional(),
+    /** Changelog file or glob. Present on `kind: "push"`. */
+    path: z.string().optional(),
+    /** Present on `kind: "push"`: verify ownership, mint a token, add the Action. */
+    setupSteps: z.array(ListingSetupStepSchema).optional(),
+});
+export const ListingOrgPointerSchema = z.strictObject({
+    slug: z.string(),
+    name: z.string(),
+    webUrl: z.string(),
+});
+export const ListingValidationResultSchema = z.strictObject({
+    valid: z.boolean(),
+    errors: z.array(ListingIssueSchema),
+    domainStatus: z.enum(["unlisted", "listed", "stub"]),
+    /** Present when domainStatus is "listed" or "stub". */
+    org: ListingOrgPointerSchema.optional(),
+    /** Present when valid: identity fields as they would land. */
+    identity: z
+        .strictObject({
+        name: z.string(),
+        slug: z.string(),
+        domain: z.string(),
+    })
+        .optional(),
+    products: z.array(z.strictObject({ name: z.string(), locationCount: z.number() })).optional(),
+    locations: z.array(ListingLocationSchema),
+});
+export const ListingActivateResultSchema = z.strictObject({
+    /** True when this call created the stub; false for the existing-stub carve-out. */
+    activated: z.boolean(),
+    org: z.strictObject({
+        slug: z.string(),
+        name: z.string(),
+        status: z.enum(["stub", "tracked"]),
+        webUrl: z.string(),
+    }),
+    trackingRequested: z.boolean(),
+});
+/**
+ * Ownership claim flow (#1947 epic item 2): a signed-in user proves control
+ * of a listed domain via a well-known token file OR a DNS TXT record.
+ */
+export const ListingClaimBodySchema = z.strictObject({
+    domain: z.string().min(1).max(255),
+});
+export const ListingClaimVerifyBodySchema = z.strictObject({
+    claimId: z.string().min(1),
+});
+export const OrgClaimStatusSchema = z.enum(["pending", "verified", "expired", "revoked"]);
+export const ClaimMethodSchema = z.enum(["well-known", "dns-txt"]);
+/**
+ * `token` + `instructions` are only present while the claim is `pending` (or
+ * on mint) — once verified there's nothing left to prove, and an expired
+ * claim's token is stale.
+ */
+export const OrgClaimSchema = z.strictObject({
+    id: z.string(),
+    org: ListingOrgPointerSchema,
+    status: OrgClaimStatusSchema,
+    method: ClaimMethodSchema.optional(),
+    token: z.string().optional(),
+    createdAt: z.string(),
+    verifiedAt: z.string().optional(),
+    /** Set once the claim was ended by its owner or an admin (#2389). */
+    revokedAt: z.string().optional(),
+    expiresAt: z.string(),
+    instructions: z
+        .strictObject({
+        wellKnownUrl: z.string(),
+        dnsRecordName: z.string(),
+    })
+        .optional(),
+});
+export const ClaimCheckOutcomeSchema = z.enum(["ok", "mismatch", "unreachable"]);
+export const ClaimVerifyResultSchema = z.strictObject({
+    verified: z.boolean(),
+    checked: z.strictObject({
+        wellKnown: ClaimCheckOutcomeSchema,
+        dnsTxt: ClaimCheckOutcomeSchema,
+    }),
+    claim: OrgClaimSchema,
+});
+export const ListingClaimsResultSchema = z.strictObject({
+    claims: z.array(OrgClaimSchema),
+});
+/**
+ * Admin view of every claim on an org (`GET /v1/orgs/:slug/claims`, #2389).
+ * Never includes the proof token.
+ */
+export const AdminOrgClaimSchema = z.strictObject({
+    id: z.string(),
+    userId: z.string(),
+    status: OrgClaimStatusSchema,
+    method: ClaimMethodSchema.nullable(),
+    createdAt: z.string(),
+    verifiedAt: z.string().nullable(),
+    expiresAt: z.string(),
+    revokedAt: z.string().nullable(),
+    revokedBy: z.string().nullable(),
+    revokeReason: z.string().nullable(),
+});
+export const ListOrgClaimsResponseSchema = z.strictObject({
+    claims: z.array(AdminOrgClaimSchema),
+});
+/** `DELETE /v1/orgs/:slug/claims/:id` body — admins must say why. */
+export const RevokeOrgClaimBodySchema = z.strictObject({
+    reason: z.string().trim().min(1).max(500),
+});
+/**
+ * Self-serve Tier-1 promotion (#1947): a verified owner
+ * promotes their claimed stub to `tracked`. Independent of the internal
+ * materialization plan — this is the stable public projection.
+ */
+export const ListingPromoteBodySchema = z.strictObject({
+    domain: z.string().min(1).max(255),
+});
+export const ListingPromoteLocatorOutcomeSchema = z.enum(["live", "queued-for-review"]);
+export const ListingPromoteLocatorSchema = z.strictObject({
+    locator: z.string(),
+    outcome: ListingPromoteLocatorOutcomeSchema,
+});
+export const ListingPromoteResultSchema = z.strictObject({
+    promoted: z.boolean(),
+    /** Present and true only for the idempotent already-`tracked` no-op. */
+    alreadyTracked: z.boolean().optional(),
+    sources: z.strictObject({
+        created: z.number(),
+        matched: z.number(),
+    }),
+    locators: z.array(ListingPromoteLocatorSchema),
+});
+/**
+ * Public capability flags for the listing lane. Anonymous + always reachable
+ * (does NOT 404 when either kill switch is off) so the web UI can hide CTAs
+ * instead of offering a button that fails with "Not found".
+ */
+export const ListingCapabilitiesSchema = z.strictObject({
+    /** `listing-self-serve-enabled` — validate / activate / claim / verify. */
+    selfServeEnabled: z.boolean(),
+    /** `listing-self-serve-promotion-enabled` — POST /v1/listing/promote. */
+    promotionEnabled: z.boolean(),
+});

package/dist/schemas/lookups.d.ts

@@ -0,0 +1,285 @@
+import { z } from "zod";
+/**
+ * Status flags returned by `POST /v1/lookups`:
+ * - `indexed` — the source was just materialized and releases were ingested.
+ * - `existing` — the source already lives in the registry; we returned it as-is.
+ * - `empty` — the repo exists but has no releases or CHANGELOG to ingest. A
+ *   hidden stub row is left behind so the next cron pass can pick it up.
+ * - `not_found` — the repo doesn't exist, is archived, or isn't reachable.
+ * - `deferred` — GitHub probe rate-limited or 5xx'd; the next cron pass retries.
+ */
+export declare const LookupStatusSchema: z.ZodEnum<{
+    deferred: "deferred";
+    empty: "empty";
+    existing: "existing";
+    indexed: "indexed";
+    not_found: "not_found";
+}>;
+/** Body accepted by `POST /v1/lookups`. v1 only supports GitHub coordinates. */
+export declare const LookupBodySchema: z.ZodObject<{
+    provider: z.ZodLiteral<"github">;
+    coordinate: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Source row embedded in `LookupResponse`. The handler returns the full
+ * Drizzle row, so `z.looseObject(...)` lets stable fields stay typed while
+ * letting timestamps/counters that aren't load-bearing for callers ride
+ * along unmodelled. Same pattern as `SourceMutationResponseSchema`.
+ */
+export declare const LookupSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    url: z.ZodString;
+    orgId: z.ZodNullable<z.ZodString>;
+    productId: z.ZodNullable<z.ZodString>;
+    isHidden: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    discovery: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        curated: "curated";
+        on_demand: "on_demand";
+    }>>;
+    metadata: z.ZodNullable<z.ZodString>;
+    stars: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    starsFetchedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** Release row embedded in `LookupResponse.releases`. Loose for the same reason as `LookupSourceSchema`. */
+export declare const LookupReleaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+    title: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+/** "Did you mean" rail returned alongside not_found / empty / deferred outcomes. */
+export declare const LookupRelatedOrgSchema: z.ZodNullable<z.ZodObject<{
+    org: z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+/**
+ * Response returned by `POST /v1/lookups`. The `source` and `releases` fields
+ * are populated for `indexed` / `existing` outcomes; `empty` populates only
+ * `source`; `not_found` / `deferred` populate neither.
+ */
+export declare const LookupResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        deferred: "deferred";
+        empty: "empty";
+        existing: "existing";
+        indexed: "indexed";
+        not_found: "not_found";
+    }>;
+    source: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodString;
+        url: z.ZodString;
+        orgId: z.ZodNullable<z.ZodString>;
+        productId: z.ZodNullable<z.ZodString>;
+        isHidden: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        discovery: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            curated: "curated";
+            on_demand: "on_demand";
+        }>>;
+        metadata: z.ZodNullable<z.ZodString>;
+        stars: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        starsFetchedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    releases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+        title: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        publishedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>>>;
+    relatedOrg: z.ZodNullable<z.ZodObject<{
+        org: z.ZodObject<{
+            id: z.ZodString;
+            slug: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            slug: z.ZodString;
+            name: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Response from `GET /v1/lookups/source-by-slug?slug=…`. */
+export declare const LookupSourceBySlugResponseSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    sourceSlug: z.ZodString;
+    orgSlug: z.ZodString;
+}, z.core.$strip>;
+/** Response from `GET /v1/lookups/product-by-slug?slug=…`. */
+export declare const LookupProductBySlugResponseSchema: z.ZodObject<{
+    productId: z.ZodString;
+    productSlug: z.ZodString;
+    orgSlug: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Response from `GET /v1/lookups/by-domain?domain=…`. Resolves against the
+ * registry; on a complete miss may just-in-time materialize a stub from
+ * `/.well-known/releases.json` when listing is enabled (#2030). Both an org
+ * and product list can be present when a product alias points at the same
+ * domain its parent org owns.
+ */
+export declare const DomainLookupOrgSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    domain: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    category: z.ZodNullable<z.ZodString>;
+    avatarUrl: z.ZodNullable<z.ZodString>;
+    matchedVia: z.ZodEnum<{
+        alias: "alias";
+        primary: "primary";
+    }>;
+    status: z.ZodOptional<z.ZodEnum<{
+        stub: "stub";
+        tracked: "tracked";
+    }>>;
+    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        feed: z.ZodOptional<z.ZodString>;
+        github: z.ZodOptional<z.ZodString>;
+        appstore: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        canonical: z.ZodBoolean;
+        basis: z.ZodEnum<{
+            curator: "curator";
+            declared: "declared";
+            detected: "detected";
+            generated: "generated";
+        }>;
+        productId: z.ZodNullable<z.ZodString>;
+        sourceId: z.ZodNullable<z.ZodString>;
+        publish: z.ZodOptional<z.ZodLiteral<"push">>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const DomainLookupProductSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    orgId: z.ZodString;
+    orgSlug: z.ZodString;
+    orgName: z.ZodString;
+    category: z.ZodNullable<z.ZodEnum<{
+        ai: "ai";
+        cloud: "cloud";
+        commerce: "commerce";
+        crm: "crm";
+        database: "database";
+        design: "design";
+        "developer-tools": "developer-tools";
+        devops: "devops";
+        finance: "finance";
+        framework: "framework";
+        infrastructure: "infrastructure";
+        observability: "observability";
+        productivity: "productivity";
+        security: "security";
+    }>>;
+    kind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        desktop: "desktop";
+        docs: "docs";
+        integration: "integration";
+        mobile: "mobile";
+        platform: "platform";
+        sdk: "sdk";
+        tool: "tool";
+    }>>>;
+}, z.core.$strip>;
+export declare const DomainLookupResponseSchema: z.ZodObject<{
+    domain: z.ZodString;
+    org: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        domain: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        category: z.ZodNullable<z.ZodString>;
+        avatarUrl: z.ZodNullable<z.ZodString>;
+        matchedVia: z.ZodEnum<{
+            alias: "alias";
+            primary: "primary";
+        }>;
+        status: z.ZodOptional<z.ZodEnum<{
+            stub: "stub";
+            tracked: "tracked";
+        }>>;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodOptional<z.ZodString>;
+            feed: z.ZodOptional<z.ZodString>;
+            github: z.ZodOptional<z.ZodString>;
+            appstore: z.ZodOptional<z.ZodString>;
+            file: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            canonical: z.ZodBoolean;
+            basis: z.ZodEnum<{
+                curator: "curator";
+                declared: "declared";
+                detected: "detected";
+                generated: "generated";
+            }>;
+            productId: z.ZodNullable<z.ZodString>;
+            sourceId: z.ZodNullable<z.ZodString>;
+            publish: z.ZodOptional<z.ZodLiteral<"push">>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    products: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        orgId: z.ZodString;
+        orgSlug: z.ZodString;
+        orgName: z.ZodString;
+        category: z.ZodNullable<z.ZodEnum<{
+            ai: "ai";
+            cloud: "cloud";
+            commerce: "commerce";
+            crm: "crm";
+            database: "database";
+            design: "design";
+            "developer-tools": "developer-tools";
+            devops: "devops";
+            finance: "finance";
+            framework: "framework";
+            infrastructure: "infrastructure";
+            observability: "observability";
+            productivity: "productivity";
+            security: "security";
+        }>>;
+        kind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            desktop: "desktop";
+            docs: "docs";
+            integration: "integration";
+            mobile: "mobile";
+            platform: "platform";
+            sdk: "sdk";
+            tool: "tool";
+        }>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=lookups.d.ts.map

package/dist/schemas/lookups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookups.d.ts","sourceRoot":"","sources":["../../src/schemas/lookups.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;;EAAoE,CAAC;AAEpG,gFAAgF;AAChF,eAAO,MAAM,gBAAgB;;;iBAK3B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;iBAc7B,CAAC;AAEH,4GAA4G;AAC5G,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;kBAOtB,CAAC;AAEd;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,gCAAgC;;;;iBAI3C,CAAC;AAEH,8DAA8D;AAC9D,eAAO,MAAM,iCAAiC;;;;iBAI5C,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIrC,CAAC"}

package/{src/schemas/lookups.ts → dist/schemas/lookups.js}

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { KIND_VALUES } from "@buildinternet/releases-core/kinds";
 import { CategorySchema, OrgStatusSchema, ReleaseLocationItemSchema } from "./shared.js";
-
 /**
  * Status flags returned by `POST /v1/lookups`:
  * - `indexed` — the source was just materialized and releases were ingested.
@@ -12,15 +11,13 @@ import { CategorySchema, OrgStatusSchema, ReleaseLocationItemSchema } from "./sh
  * - `deferred` — GitHub probe rate-limited or 5xx'd; the next cron pass retries.
  */
 export const LookupStatusSchema = z.enum(["indexed", "existing", "empty", "not_found", "deferred"]);
-
 /** Body accepted by `POST /v1/lookups`. v1 only supports GitHub coordinates. */
 export const LookupBodySchema = z.object({
-  provider: z.literal("github"),
-  coordinate: z.string().regex(/^[^/\s]+\/[^/\s]+$/, {
-    message: "coordinate must match {org}/{repo}",
-  }),
+    provider: z.literal("github"),
+    coordinate: z.string().regex(/^[^/\s]+\/[^/\s]+$/, {
+        message: "coordinate must match {org}/{repo}",
+    }),
 });
-
 /**
  * Source row embedded in `LookupResponse`. The handler returns the full
  * Drizzle row, so `z.looseObject(...)` lets stable fields stay typed while
@@ -28,67 +25,59 @@ export const LookupBodySchema = z.object({
  * along unmodelled. Same pattern as `SourceMutationResponseSchema`.
  */
 export const LookupSourceSchema = z.looseObject({
-  id: z.string(),
-  slug: z.string(),
-  name: z.string(),
-  type: z.string(),
-  url: z.string(),
-  orgId: z.string().nullable(),
-  productId: z.string().nullable(),
-  isHidden: z.boolean().nullable().optional(),
-  discovery: z.enum(["curated", "agent", "on_demand"]).optional(),
-  metadata: z.string().nullable(),
-  stars: z.number().int().min(0).nullable().optional(),
-  starsFetchedAt: z.string().nullable().optional(),
-  createdAt: z.string().optional(),
+    id: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    type: z.string(),
+    url: z.string(),
+    orgId: z.string().nullable(),
+    productId: z.string().nullable(),
+    isHidden: z.boolean().nullable().optional(),
+    discovery: z.enum(["curated", "agent", "on_demand"]).optional(),
+    metadata: z.string().nullable(),
+    stars: z.number().int().min(0).nullable().optional(),
+    starsFetchedAt: z.string().nullable().optional(),
+    createdAt: z.string().optional(),
 });
-
 /** Release row embedded in `LookupResponse.releases`. Loose for the same reason as `LookupSourceSchema`. */
 export const LookupReleaseSchema = z.looseObject({
-  id: z.string(),
-  sourceId: z.string(),
-  version: z.string().nullable(),
-  title: z.string(),
-  url: z.string().nullable(),
-  publishedAt: z.string().nullable(),
+    id: z.string(),
+    sourceId: z.string(),
+    version: z.string().nullable(),
+    title: z.string(),
+    url: z.string().nullable(),
+    publishedAt: z.string().nullable(),
 });
-
 /** "Did you mean" rail returned alongside not_found / empty / deferred outcomes. */
 export const LookupRelatedOrgSchema = z
-  .object({
+    .object({
     org: z.object({ id: z.string(), slug: z.string(), name: z.string() }),
-    sources: z.array(
-      z.object({ id: z.string(), slug: z.string(), name: z.string(), url: z.string() }),
-    ),
-  })
-  .nullable();
-
+    sources: z.array(z.object({ id: z.string(), slug: z.string(), name: z.string(), url: z.string() })),
+})
+    .nullable();
 /**
  * Response returned by `POST /v1/lookups`. The `source` and `releases` fields
  * are populated for `indexed` / `existing` outcomes; `empty` populates only
  * `source`; `not_found` / `deferred` populate neither.
  */
 export const LookupResponseSchema = z.object({
-  status: LookupStatusSchema,
-  source: LookupSourceSchema.optional(),
-  releases: z.array(LookupReleaseSchema).optional(),
-  relatedOrg: LookupRelatedOrgSchema,
+    status: LookupStatusSchema,
+    source: LookupSourceSchema.optional(),
+    releases: z.array(LookupReleaseSchema).optional(),
+    relatedOrg: LookupRelatedOrgSchema,
 });
-
 /** Response from `GET /v1/lookups/source-by-slug?slug=…`. */
 export const LookupSourceBySlugResponseSchema = z.object({
-  sourceId: z.string(),
-  sourceSlug: z.string(),
-  orgSlug: z.string(),
+    sourceId: z.string(),
+    sourceSlug: z.string(),
+    orgSlug: z.string(),
 });
-
 /** Response from `GET /v1/lookups/product-by-slug?slug=…`. */
 export const LookupProductBySlugResponseSchema = z.object({
-  productId: z.string(),
-  productSlug: z.string(),
-  orgSlug: z.string(),
+    productId: z.string(),
+    productSlug: z.string(),
+    orgSlug: z.string(),
 });
-
 /**
  * Response from `GET /v1/lookups/by-domain?domain=…`. Resolves against the
  * registry; on a complete miss may just-in-time materialize a stub from
@@ -97,40 +86,38 @@ export const LookupProductBySlugResponseSchema = z.object({
  * domain its parent org owns.
  */
 export const DomainLookupOrgSchema = z.object({
-  id: z.string(),
-  slug: z.string(),
-  name: z.string(),
-  domain: z.string().nullable(),
-  description: z.string().nullable(),
-  category: z.string().nullable(),
-  avatarUrl: z.string().nullable(),
-  matchedVia: z.enum(["primary", "alias"]),
-  /** Org tier (#1947). Optional for mid-deploy tolerance; absent ⇒ `"tracked"`. */
-  status: OrgStatusSchema.optional(),
-  /**
-   * Declared release locations (#1947) for a stub org — the "check these
-   * locations" answer when the domain resolves to an org with no sources yet.
-   * Omitted/empty for a tracked org.
-   */
-  locations: z.array(ReleaseLocationItemSchema).optional(),
+    id: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    domain: z.string().nullable(),
+    description: z.string().nullable(),
+    category: z.string().nullable(),
+    avatarUrl: z.string().nullable(),
+    matchedVia: z.enum(["primary", "alias"]),
+    /** Org tier (#1947). Optional for mid-deploy tolerance; absent ⇒ `"tracked"`. */
+    status: OrgStatusSchema.optional(),
+    /**
+     * Declared release locations (#1947) for a stub org — the "check these
+     * locations" answer when the domain resolves to an org with no sources yet.
+     * Omitted/empty for a tracked org.
+     */
+    locations: z.array(ReleaseLocationItemSchema).optional(),
 });
-
 export const DomainLookupProductSchema = z.object({
-  id: z.string(),
-  slug: z.string(),
-  name: z.string(),
-  orgId: z.string(),
-  orgSlug: z.string(),
-  orgName: z.string(),
-  // Reuses the canonical `CategorySchema` enum because the products read
-  // path resolves through `resolveCategoryInput` before persisting — unlike
-  // the search catalog category, which passes the column through raw.
-  category: CategorySchema.nullable(),
-  kind: z.enum(KIND_VALUES).nullable().optional(),
+    id: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    orgId: z.string(),
+    orgSlug: z.string(),
+    orgName: z.string(),
+    // Reuses the canonical `CategorySchema` enum because the products read
+    // path resolves through `resolveCategoryInput` before persisting — unlike
+    // the search catalog category, which passes the column through raw.
+    category: CategorySchema.nullable(),
+    kind: z.enum(KIND_VALUES).nullable().optional(),
 });
-
 export const DomainLookupResponseSchema = z.object({
-  domain: z.string(),
-  org: DomainLookupOrgSchema.nullable(),
-  products: z.array(DomainLookupProductSchema),
+    domain: z.string(),
+    org: DomainLookupOrgSchema.nullable(),
+    products: z.array(DomainLookupProductSchema),
 });