@spacefast/common 0.0.2

package/dist/contracts/events.js

@@ -0,0 +1,320 @@
+import { z } from "zod";
+const analyticsIdSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .describe("Opaque analytics id minted by the platform; never an email or a name.");
+const idSchema = z.string().min(1).max(128);
+const occurredAtSchema = z
+    .string()
+    .datetime()
+    .optional()
+    .describe("Client-side event time; the server receive time is authoritative when omitted.");
+const pathSchema = z
+    .string()
+    .min(1)
+    .max(2048)
+    .describe("Client route or URL path the event happened on, without query strings.");
+const propertyValueSchema = z.union([z.string().max(512), z.number(), z.boolean(), z.null()]);
+const propertyBagSchema = z
+    .record(z.string().max(64), propertyValueSchema)
+    .refine((value) => Object.keys(value).length <= 32, {
+    message: "Events carry at most 32 properties.",
+});
+const optionalPropertyBagSchema = propertyBagSchema.optional().default({});
+export const eventSourceSchema = z.enum([
+    "dashboard",
+    "www",
+    "cli",
+    "domain-ssh",
+    "control-plane",
+    "other",
+]);
+export const eventActorSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("analytics_id"), id: analyticsIdSchema }).strict(),
+    z.object({ type: z.literal("anonymous_id"), id: idSchema }).strict(),
+    z.object({ type: z.literal("anonymous_machine"), id: idSchema }).strict(),
+    z
+        .object({
+        type: z.literal("anonymous_session"),
+        namespace: z.string().min(1).max(64),
+        id: idSchema,
+    })
+        .strict(),
+    z.object({ type: z.literal("system"), id: idSchema }).strict(),
+]);
+const eventContextSchema = z
+    .object({
+    team_id: z.string().min(1).max(128).nullable().optional(),
+    space_id: z.string().min(1).max(128).nullable().optional(),
+    user_id: z.string().min(1).max(128).nullable().optional(),
+    version_id: z.string().min(1).max(128).nullable().optional(),
+    client: z.string().min(1).max(128).nullable().optional(),
+    surface: z.string().min(1).max(128).nullable().optional(),
+})
+    .strict()
+    .optional()
+    .default({});
+const pageViewedPropertiesSchema = z
+    .object({
+    path: pathSchema,
+    referrer: z.string().max(2048).nullable().optional(),
+})
+    .strict();
+const webVitalPropertiesSchema = z
+    .object({
+    metric: z.enum(["CLS", "FCP", "INP", "LCP", "TTFB"]),
+    value: z.number(),
+    path: pathSchema,
+})
+    .strict();
+const clientErrorPropertiesSchema = z
+    .object({
+    error_class: z.string().min(1).max(128),
+    path: pathSchema.nullable().optional(),
+})
+    .strict();
+const cliCommandPropertiesSchema = z
+    .object({
+    command: z.string().min(1).max(128),
+    version: z.string().min(1).max(64),
+    error_class: z.string().min(1).max(128).optional(),
+})
+    .strict();
+const browserFunnelPropertiesSchema = propertyBagSchema.default({});
+const domainSearchPropertiesSchema = z
+    .object({
+    action: z.enum(["suggestions", "availability", "whois"]).nullable().optional(),
+    cols: z.number().int().min(1).max(500).nullable().optional(),
+    duration_ms: z
+        .number()
+        .int()
+        .min(0)
+        .max(24 * 60 * 60 * 1000)
+        .nullable()
+        .optional(),
+    reason: z
+        .enum([
+        "closed",
+        "ended",
+        "exec_rejected",
+        "lookup_rate_limited",
+        "renderer_failed",
+        "session_limit",
+        "shutdown",
+        "started",
+    ])
+        .nullable()
+        .optional(),
+    rows: z.number().int().min(1).max(200).nullable().optional(),
+    source: z.literal("ssh"),
+    source_family: z.enum(["ipv4", "ipv6", "unknown"]),
+    source_hash: z
+        .string()
+        .trim()
+        .regex(/^[a-f0-9]{64}$/)
+        .nullable()
+        .optional(),
+    units: z.number().int().min(1).max(160).nullable().optional(),
+})
+    .strict();
+const publishReceiptPropertiesSchema = z
+    .object({
+    access: z.string().min(1).max(64),
+    anonymous: z.boolean(),
+    upload_count: z.number().int().nonnegative(),
+    reused_count: z.number().int().nonnegative(),
+    ignored_count: z.number().int().nonnegative(),
+    no_changes: z.boolean(),
+})
+    .strict();
+const versionIntentPropertiesSchema = z
+    .object({
+    access: z.string().min(1).max(64),
+    file_count: z.number().int().nonnegative(),
+    open_session: z.boolean(),
+    upload_count: z.number().int().nonnegative(),
+    skipped_count: z.number().int().nonnegative(),
+    ignored_count: z.number().int().nonnegative(),
+    no_changes: z.boolean(),
+    finalize_required: z.boolean(),
+    source_kind: z.string().min(1).max(64),
+})
+    .strict();
+const versionFinalizePropertiesSchema = z
+    .object({
+    access: z.string().min(1).max(64),
+    async: z.boolean(),
+    operation_id: z.string().min(1).max(128),
+    has_redirects: z.boolean(),
+    has_headers: z.boolean(),
+})
+    .strict();
+const versionPromotePropertiesSchema = z
+    .object({
+    access: z.string().min(1).max(64),
+    async: z.boolean(),
+    operation_id: z.string().min(1).max(128),
+})
+    .strict();
+const featureBlockedPropertiesSchema = z
+    .object({
+    feature: z.string().min(1).max(128),
+    plan: z.string().min(1).max(64).nullable(),
+    outcome: z.literal("blocked"),
+})
+    .strict();
+const abuseLimitPropertiesSchema = z
+    .object({
+    kind: z.enum(["rate_limit", "quota"]),
+    code: z.string().min(1).max(128),
+    key_class: z.string().min(1).max(128).nullable(),
+    limit: z.number().nullable(),
+})
+    .strict();
+export const EVENT_CATALOG = {
+    "client.page_viewed": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: pageViewedPropertiesSchema,
+    },
+    "client.web_vital.measured": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: webVitalPropertiesSchema,
+    },
+    "client.error.observed": {
+        sources: ["dashboard", "www", "cli", "other"],
+        actors: ["analytics_id", "anonymous_id", "anonymous_machine"],
+        properties: clientErrorPropertiesSchema,
+    },
+    "cli.command.completed": {
+        sources: ["cli"],
+        actors: ["anonymous_machine"],
+        properties: cliCommandPropertiesSchema,
+    },
+    "browser.funnel.claim_page_viewed": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: browserFunnelPropertiesSchema,
+    },
+    "browser.funnel.claim_token_validated": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: browserFunnelPropertiesSchema,
+    },
+    "browser.funnel.space_claimed": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: browserFunnelPropertiesSchema,
+    },
+    "browser.funnel.claim_rescue_countdown_viewed": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: browserFunnelPropertiesSchema,
+    },
+    "browser.funnel.claim_reminder_requested": {
+        sources: ["dashboard", "www"],
+        actors: ["analytics_id", "anonymous_id"],
+        properties: browserFunnelPropertiesSchema,
+    },
+    "domain.search.session_started": {
+        sources: ["domain-ssh"],
+        actors: ["anonymous_session"],
+        properties: domainSearchPropertiesSchema,
+    },
+    "domain.search.session_ended": {
+        sources: ["domain-ssh"],
+        actors: ["anonymous_session"],
+        properties: domainSearchPropertiesSchema,
+    },
+    "domain.search.lookup_requested": {
+        sources: ["domain-ssh"],
+        actors: ["anonymous_session"],
+        properties: domainSearchPropertiesSchema,
+    },
+    "publish.receipt.created": {
+        sources: ["control-plane"],
+        actors: ["analytics_id", "anonymous_id", "system"],
+        properties: publishReceiptPropertiesSchema,
+    },
+    "version.intent.created": {
+        sources: ["control-plane"],
+        actors: ["analytics_id", "anonymous_id", "system"],
+        properties: versionIntentPropertiesSchema,
+    },
+    "version.finalize.queued": {
+        sources: ["control-plane"],
+        actors: ["analytics_id", "anonymous_id", "system"],
+        properties: versionFinalizePropertiesSchema,
+    },
+    "version.promote.queued": {
+        sources: ["control-plane"],
+        actors: ["analytics_id", "anonymous_id", "system"],
+        properties: versionPromotePropertiesSchema,
+    },
+    "feature.blocked": {
+        sources: ["control-plane"],
+        actors: ["analytics_id", "anonymous_id", "system"],
+        properties: featureBlockedPropertiesSchema,
+    },
+    "abuse.limit_tripped": {
+        sources: ["control-plane"],
+        actors: ["system"],
+        properties: abuseLimitPropertiesSchema,
+    },
+};
+export const eventNameSchema = z.enum(Object.keys(EVENT_CATALOG));
+export const eventPayloadSchema = z
+    .object({
+    id: z.string().min(1).max(128).optional(),
+    name: eventNameSchema,
+    actor: eventActorSchema,
+    context: eventContextSchema,
+    properties: optionalPropertyBagSchema,
+    occurredAt: occurredAtSchema,
+})
+    .strict();
+export const EVENT_MAX_EVENTS_PER_REQUEST = 20;
+export const EVENT_BODY_CAP_BYTES = 64 * 1024;
+function addSchemaIssues(ctx, path, issues) {
+    for (const issue of issues) {
+        ctx.addIssue({
+            code: "custom",
+            message: issue.message,
+            path: [...path, ...issue.path],
+        });
+    }
+}
+export const eventIngestSchema = z
+    .object({
+    source: eventSourceSchema.default("other"),
+    events: z.array(eventPayloadSchema).min(1).max(EVENT_MAX_EVENTS_PER_REQUEST),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    value.events.forEach((event, index) => {
+        const spec = EVENT_CATALOG[event.name];
+        if (!spec.sources.includes(value.source)) {
+            ctx.addIssue({
+                code: "custom",
+                message: `Event ${event.name} is not registered for source ${value.source}.`,
+                path: ["events", index, "name"],
+            });
+        }
+        if (!spec.actors.includes(event.actor.type)) {
+            ctx.addIssue({
+                code: "custom",
+                message: `Event ${event.name} does not accept actor type ${event.actor.type}.`,
+                path: ["events", index, "actor", "type"],
+            });
+        }
+        const parsedProperties = spec.properties.safeParse(event.properties ?? {});
+        if (!parsedProperties.success) {
+            addSchemaIssues(ctx, ["events", index, "properties"], parsedProperties.error.issues);
+        }
+    });
+});
+export const eventAcceptedSchema = z.object({
+    accepted: z.number().int().nonnegative(),
+});

package/dist/contracts/fast-domain-search.d.ts

@@ -0,0 +1,19 @@
+export declare const FAST_DOMAIN_SEARCH_SERVICE_NAME = "fastdomainsearch";
+export declare const FAST_DOMAIN_SEARCH_SERVICE_HEADERS: {
+    readonly bodySha256: "x-spacefast-service-body-sha256";
+    readonly nonce: "x-spacefast-service-nonce";
+    readonly service: "x-spacefast-service";
+    readonly signature: "x-spacefast-service-signature";
+    readonly timestamp: "x-spacefast-service-timestamp";
+};
+export declare const FAST_DOMAIN_SEARCH_SIGNATURE_VERSION = "v1";
+export declare const FAST_DOMAIN_SEARCH_MIN_SERVICE_SECRET_LENGTH = 32;
+export declare function normalizeFastDomainSearchServiceSecret(secret: string | undefined): string | null;
+export declare function fastDomainSearchServiceSignaturePayload(input: {
+    bodySha256: string;
+    method: string;
+    nonce: string;
+    path: string;
+    service?: string;
+    timestamp: string;
+}): string;

package/dist/contracts/fast-domain-search.js

@@ -0,0 +1,22 @@
+export const FAST_DOMAIN_SEARCH_SERVICE_NAME = "fastdomainsearch";
+export const FAST_DOMAIN_SEARCH_SERVICE_HEADERS = {
+    bodySha256: "x-spacefast-service-body-sha256",
+    nonce: "x-spacefast-service-nonce",
+    service: "x-spacefast-service",
+    signature: "x-spacefast-service-signature",
+    timestamp: "x-spacefast-service-timestamp",
+};
+export const FAST_DOMAIN_SEARCH_SIGNATURE_VERSION = "v1";
+export const FAST_DOMAIN_SEARCH_MIN_SERVICE_SECRET_LENGTH = 32;
+export function normalizeFastDomainSearchServiceSecret(secret) {
+    const value = secret?.trim();
+    if (!value ||
+        value === "replace-me" ||
+        value.length < FAST_DOMAIN_SEARCH_MIN_SERVICE_SECRET_LENGTH) {
+        return null;
+    }
+    return value;
+}
+export function fastDomainSearchServiceSignaturePayload(input) {
+    return `${input.service ?? FAST_DOMAIN_SEARCH_SERVICE_NAME}\n${input.method.toUpperCase()}\n${input.path}\n${input.timestamp}\n${input.nonce}\n${input.bodySha256}`;
+}

package/dist/contracts/features.d.ts

@@ -0,0 +1,240 @@
+import { z } from "zod";
+export declare const PLAN_CODES: readonly ["free", "personal", "work", "enterprise", "internal"];
+export declare const planCodeSchema: z.ZodEnum<{
+    free: "free";
+    personal: "personal";
+    work: "work";
+    enterprise: "enterprise";
+    internal: "internal";
+}>;
+export type PlanCode = z.infer<typeof planCodeSchema>;
+export declare const DEFAULT_PLAN_CODE: PlanCode;
+export declare const FEATURE_KEYS: readonly ["plans.paid.available", "anonymous.publishing", "beta.enrollment_gate", "domains.search", "domains.registration", "domains.dns_management", "domains.proxy_bindings", "annotations.preview_loader", "annotations.comments", "annotations.anonymous_reviewers", "annotations.cli", "annotations.notices", "annotations.spacefast_token", "annotations.published_comments", "sites.dedicated_runtime", "shelf", "tags", "zero"];
+export declare const featureKeySchema: z.ZodEnum<{
+    "plans.paid.available": "plans.paid.available";
+    "anonymous.publishing": "anonymous.publishing";
+    "beta.enrollment_gate": "beta.enrollment_gate";
+    "domains.search": "domains.search";
+    "domains.registration": "domains.registration";
+    "domains.dns_management": "domains.dns_management";
+    "domains.proxy_bindings": "domains.proxy_bindings";
+    "annotations.preview_loader": "annotations.preview_loader";
+    "annotations.comments": "annotations.comments";
+    "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
+    "annotations.cli": "annotations.cli";
+    "annotations.notices": "annotations.notices";
+    "annotations.spacefast_token": "annotations.spacefast_token";
+    "annotations.published_comments": "annotations.published_comments";
+    "sites.dedicated_runtime": "sites.dedicated_runtime";
+    shelf: "shelf";
+    tags: "tags";
+    zero: "zero";
+}>;
+export type FeatureKey = z.infer<typeof featureKeySchema>;
+export declare const FEATURE_OVERRIDE_STATES: readonly ["enabled", "disabled", "kill_switch"];
+export declare const featureOverrideStateSchema: z.ZodEnum<{
+    enabled: "enabled";
+    disabled: "disabled";
+    kill_switch: "kill_switch";
+}>;
+export type FeatureOverrideState = z.infer<typeof featureOverrideStateSchema>;
+export declare const planLimitValueSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+export type PlanLimitValue = z.infer<typeof planLimitValueSchema>;
+export declare const planLimitsSchema: z.ZodObject<{
+    storageBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    teamMembers: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    subTeams: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    externalDomainGroups: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    publicImmutableVersionWindowDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    versionRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    versionGatedKeepDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    egressBytesPerDay: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    maxFileBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    maxVersionFiles: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    routingRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    auditLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    buildAccessLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    buildsDeploysMonthly: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    analyticsRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+}, z.core.$strip>;
+export type PlanLimits = z.infer<typeof planLimitsSchema>;
+export declare const teamEntitlementsSchema: z.ZodObject<{
+    planCode: z.ZodEnum<{
+        free: "free";
+        personal: "personal";
+        work: "work";
+        enterprise: "enterprise";
+        internal: "internal";
+    }>;
+    limits: z.ZodObject<{
+        storageBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        teamMembers: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        subTeams: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        externalDomainGroups: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        publicImmutableVersionWindowDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        versionRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        versionGatedKeepDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        egressBytesPerDay: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        maxFileBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        maxVersionFiles: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        routingRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        auditLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        buildAccessLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        buildsDeploysMonthly: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        analyticsRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    }, z.core.$strip>;
+    headersBasicAuth: z.ZodBoolean;
+    externalProxy: z.ZodBoolean;
+    runtimePhpWorkers: z.ZodNumber;
+    analyticsHourlyGranularity: z.ZodBoolean;
+    versionDiagnosticsIncluded: z.ZodBoolean;
+}, z.core.$strip>;
+export type TeamEntitlements = z.infer<typeof teamEntitlementsSchema>;
+export declare const teamEntitlementsResponseSchema: z.ZodObject<{
+    planCode: z.ZodEnum<{
+        free: "free";
+        personal: "personal";
+        work: "work";
+        enterprise: "enterprise";
+        internal: "internal";
+    }>;
+    headersBasicAuth: z.ZodBoolean;
+    externalProxy: z.ZodBoolean;
+    runtimePhpWorkers: z.ZodNumber;
+    analyticsHourlyGranularity: z.ZodBoolean;
+    versionDiagnosticsIncluded: z.ZodBoolean;
+    limits: z.ZodObject<{
+        storageBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        teamMembers: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        subTeams: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        externalDomainGroups: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        publicImmutableVersionWindowDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        maxFileBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        maxVersionFiles: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        routingRules: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        auditLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        buildAccessLogRetentionHours: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        buildsDeploysMonthly: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+        analyticsRetentionDays: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TeamEntitlementsResponse = z.infer<typeof teamEntitlementsResponseSchema>;
+export type PlanDefinition = {
+    code: PlanCode;
+    name: string;
+    monthlyPriceUsd: number | null;
+    limits: PlanLimits;
+    headersBasicAuth: boolean;
+    externalProxy: boolean;
+    runtimePhpWorkers: number;
+    analyticsHourlyGranularity: boolean;
+};
+export type FeatureDefinition = {
+    key: FeatureKey;
+    name: string;
+    description: string;
+    defaultEnabled: boolean;
+    enabledInDevelopment?: boolean;
+    enabledForA8c: boolean;
+    planDefaults: Partial<Record<PlanCode, boolean>>;
+};
+export declare const PLAN_DEFINITIONS: Record<PlanCode, PlanDefinition>;
+export declare const FEATURE_DEFINITIONS: Record<FeatureKey, FeatureDefinition>;
+export declare const featureStateSourceSchema: z.ZodEnum<{
+    default: "default";
+    kill_switch: "kill_switch";
+    env: "env";
+    override: "override";
+}>;
+export declare const FeatureStateSchema: z.ZodObject<{
+    key: z.ZodEnum<{
+        "plans.paid.available": "plans.paid.available";
+        "anonymous.publishing": "anonymous.publishing";
+        "beta.enrollment_gate": "beta.enrollment_gate";
+        "domains.search": "domains.search";
+        "domains.registration": "domains.registration";
+        "domains.dns_management": "domains.dns_management";
+        "domains.proxy_bindings": "domains.proxy_bindings";
+        "annotations.preview_loader": "annotations.preview_loader";
+        "annotations.comments": "annotations.comments";
+        "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
+        "annotations.cli": "annotations.cli";
+        "annotations.notices": "annotations.notices";
+        "annotations.spacefast_token": "annotations.spacefast_token";
+        "annotations.published_comments": "annotations.published_comments";
+        "sites.dedicated_runtime": "sites.dedicated_runtime";
+        shelf: "shelf";
+        tags: "tags";
+        zero: "zero";
+    }>;
+    enabled: z.ZodBoolean;
+    source: z.ZodEnum<{
+        default: "default";
+        kill_switch: "kill_switch";
+        env: "env";
+        override: "override";
+    }>;
+}, z.core.$strip>;
+export declare const FeatureStateResponseSchema: z.ZodObject<{
+    planCode: z.ZodEnum<{
+        free: "free";
+        personal: "personal";
+        work: "work";
+        enterprise: "enterprise";
+        internal: "internal";
+    }>;
+    features: z.ZodRecord<z.ZodEnum<{
+        "plans.paid.available": "plans.paid.available";
+        "anonymous.publishing": "anonymous.publishing";
+        "beta.enrollment_gate": "beta.enrollment_gate";
+        "domains.search": "domains.search";
+        "domains.registration": "domains.registration";
+        "domains.dns_management": "domains.dns_management";
+        "domains.proxy_bindings": "domains.proxy_bindings";
+        "annotations.preview_loader": "annotations.preview_loader";
+        "annotations.comments": "annotations.comments";
+        "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
+        "annotations.cli": "annotations.cli";
+        "annotations.notices": "annotations.notices";
+        "annotations.spacefast_token": "annotations.spacefast_token";
+        "annotations.published_comments": "annotations.published_comments";
+        "sites.dedicated_runtime": "sites.dedicated_runtime";
+        shelf: "shelf";
+        tags: "tags";
+        zero: "zero";
+    }>, z.ZodObject<{
+        key: z.ZodEnum<{
+            "plans.paid.available": "plans.paid.available";
+            "anonymous.publishing": "anonymous.publishing";
+            "beta.enrollment_gate": "beta.enrollment_gate";
+            "domains.search": "domains.search";
+            "domains.registration": "domains.registration";
+            "domains.dns_management": "domains.dns_management";
+            "domains.proxy_bindings": "domains.proxy_bindings";
+            "annotations.preview_loader": "annotations.preview_loader";
+            "annotations.comments": "annotations.comments";
+            "annotations.anonymous_reviewers": "annotations.anonymous_reviewers";
+            "annotations.cli": "annotations.cli";
+            "annotations.notices": "annotations.notices";
+            "annotations.spacefast_token": "annotations.spacefast_token";
+            "annotations.published_comments": "annotations.published_comments";
+            "sites.dedicated_runtime": "sites.dedicated_runtime";
+            shelf: "shelf";
+            tags: "tags";
+            zero: "zero";
+        }>;
+        enabled: z.ZodBoolean;
+        source: z.ZodEnum<{
+            default: "default";
+            kill_switch: "kill_switch";
+            env: "env";
+            override: "override";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FeatureState = z.infer<typeof FeatureStateSchema>;
+export type FeatureStateResponse = z.infer<typeof FeatureStateResponseSchema>;
+export declare function normalizePlanCode(planCode: string | null | undefined): PlanCode;
+export declare function featureDefaultForPlan(key: FeatureKey, planCode: string | null | undefined): boolean;
+/** Numeric value of a plan limit; `null` means unlimited. */
+export declare function planLimitNumber(value: PlanLimitValue): number | null;