@antasphere/chassis-contract 0.0.0-stage → 1.0.0

package/dist/entitlements.d.ts

@@ -0,0 +1,486 @@
+import { z } from 'zod';
+import type { HeaderReader, Principal } from './seams.js';
+/**
+ * The billing rail's declaration layer (the pay-per-use billing rail spec,
+ * §7 and §8b): a route says ONCE, next to its contract, what it meters, which
+ * limit it checks and which feature it needs. One chassis middleware reads
+ * the declaration and enforces it for every client of `/api/v1` at once (the
+ * dashboard, the CLI and the MCP tools are all HTTP clients of it), and a
+ * handler never checks or emits by hand.
+ *
+ * Client-safe on purpose: no Hono here. A route is referenced by its
+ * `{ method, path }` as the OpenAPI helper spells it (`{id}` params), so the
+ * tool's contract builds the registry from its route objects and the SDK can
+ * read the same declarations without pulling the server.
+ */
+/**
+ * The plan tiers, a CLOSED enum the hub owns and this contract mirrors so a
+ * tool cannot invent one (§8b). `free` is the default with no subscription;
+ * `pro` is the paid plan. "Enterprise" is not a tier but a per-account
+ * override the hub serves.
+ */
+export declare const ENTITLEMENT_TIERS: readonly ["free", "pro"];
+export type EntitlementTier = (typeof ENTITLEMENT_TIERS)[number];
+export declare const entitlementTierSchema: z.ZodEnum<{
+    free: "free";
+    pro: "pro";
+}>;
+/** The hub's name for the same closed enum (`BILLING_PLANS` in `@antasphere/contract`). */
+export declare const BILLING_PLANS: readonly ["free", "pro"];
+/**
+ * The one scope of the tool → hub machine channel (§6): a `client_credentials`
+ * token on the registry client, reaching `/usage/*` and nothing else.
+ */
+export declare const USAGE_WRITE_SCOPE = "usage:write";
+/**
+ * The error codes the three tool routes of the hub (`POST /usage/events`,
+ * `GET /usage/entitlements`, `POST /usage/check`) answer with, and the status
+ * each rides on: the hub's `USAGE_ROUTE_ERRORS` (PRDCT-2677).
+ * `tool_credential_required`: the caller is not a registry tool's machine
+ * credential. `unknown_account`: no organization holds the `accountRef` (the
+ * check and the entitlements read; the ingest answers it per event instead).
+ * `validation_error`: the body or the query does not parse. The chassis maps
+ * the check's two (`check.ts`): a 404 `unknown_account` and a 400 are the
+ * hub's judgement, allowed and logged, never an outage.
+ */
+export declare const USAGE_ROUTE_ERRORS: {
+    readonly tool_credential_required: 401;
+    readonly unknown_account: 404;
+    readonly validation_error: 400;
+};
+export type UsageRouteError = keyof typeof USAGE_ROUTE_ERRORS;
+/**
+ * The wire shape of one usage event as the hub ingests it: the hub's
+ * `usageEventSchema` (`packages/contract/src/schemas/billing.ts` of the hub,
+ * PRDCT-2625), copied here and checked against the hub's wire snapshot
+ * (`wire.ts`, `pnpm --filter @antasphere/chassis-contract wire:check`, the
+ * `hub-wire` CI job; PRDCT-2677), so the fake hub of the test kit refuses
+ * exactly what the real hub refuses (PRDCT-2629). `userId` is the HUB user
+ * (the SSO `sub`), never the tool's local id, and null when the actor is a
+ * resource owner the tool could not name; `accountRef` is the hub
+ * organization id (a uuid) the tool carries as its workspace's central
+ * account id. `toolSlug` is accepted by the hub only when it equals the
+ * calling token's registry slug — the chassis NEVER sends it: the token is
+ * the only authority on the tool's name, the body never names the tool
+ * (PRDCT-2629; `UsageEvent` in seams.ts has no such field).
+ */
+export declare const usageEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    actionKey: z.ZodOptional<z.ZodString>;
+    meter: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodNumber;
+    unit: z.ZodString;
+    occurredAt: z.ZodISODateTime;
+    workspaceId: z.ZodString;
+    accountRef: z.ZodUUID;
+    userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    via: z.ZodEnum<{
+        session: "session";
+        api_key: "api_key";
+        oauth: "oauth";
+    }>;
+    resourceType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    toolSlug: z.ZodOptional<z.ZodString>;
+    source: z.ZodObject<{
+        instanceId: z.ZodString;
+        edition: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** The batch cap of `POST /usage/events` (the hub's `USAGE_EVENTS_BATCH_MAX`): at most this many events per post. */
+export declare const USAGE_EVENTS_BATCH_MAX = 500;
+/**
+ * The body of `POST /usage/events` as the hub parses it (its
+ * `usageEventsBatchSchema`): one to `USAGE_EVENTS_BATCH_MAX` elements, each
+ * judged on its own against `usageEventSchema` afterwards.
+ */
+export declare const usageEventsBatchSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+export type UsageEventsBatch = z.infer<typeof usageEventsBatchSchema>;
+/**
+ * Why the hub did not accept an event (its `USAGE_REJECT_REASONS`, a closed
+ * list): `unknown_account`, `unknown_user`, `tool_mismatch`, and
+ * `invalid_event` (the element does not parse, its `occurredAt` falls outside
+ * the window, or its price exceeds `Number.MAX_SAFE_INTEGER`; `details` names
+ * the field).
+ */
+export declare const USAGE_REJECT_REASONS: readonly ["unknown_account", "unknown_user", "tool_mismatch", "invalid_event"];
+export declare const usageRejectReasonSchema: z.ZodEnum<{
+    unknown_account: "unknown_account";
+    unknown_user: "unknown_user";
+    tool_mismatch: "tool_mismatch";
+    invalid_event: "invalid_event";
+}>;
+export type UsageRejectReason = z.infer<typeof usageRejectReasonSchema>;
+/**
+ * One element's answer. Since phase 2 an `accepted` result carries the
+ * `credits` the hub debited for it (0 when the action has no price).
+ */
+export declare const usageEventResultSchema: z.ZodObject<{
+    id: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        duplicate: "duplicate";
+        rejected: "rejected";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        unknown_account: "unknown_account";
+        unknown_user: "unknown_user";
+        tool_mismatch: "tool_mismatch";
+        invalid_event: "invalid_event";
+    }>>;
+    details: z.ZodOptional<z.ZodUnknown>;
+    credits: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type UsageEventResult = z.infer<typeof usageEventResultSchema>;
+/**
+ * The hub's answer to `POST /usage/events`: one result per element, in the
+ * batch's order, and the three counts (always sent).
+ */
+export declare const usageIngestResultSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            duplicate: "duplicate";
+            rejected: "rejected";
+        }>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            unknown_account: "unknown_account";
+            unknown_user: "unknown_user";
+            tool_mismatch: "tool_mismatch";
+            invalid_event: "invalid_event";
+        }>>;
+        details: z.ZodOptional<z.ZodUnknown>;
+        credits: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    accepted: z.ZodNumber;
+    duplicate: z.ZodNumber;
+    rejected: z.ZodNumber;
+}, z.core.$strip>;
+export type UsageIngestResult = z.infer<typeof usageIngestResultSchema>;
+/**
+ * The window an event's `occurredAt` must fall in, measured against the
+ * moment the hub receives it: the hub's `USAGE_EVENT_MAX_PAST_MS` and
+ * `USAGE_EVENT_MAX_FUTURE_MS` (`packages/contract/src/schemas/billing.ts`
+ * of the hub), same names and values, checked against the hub's wire
+ * snapshot (`wire.ts`, `wire:check`, the `hub-wire` CI job; PRDCT-2677). Backward, seven days:
+ * the queue's retry budget is about eight and a half hours, so an outage of
+ * a night is covered many times over, and a week also covers an operator
+ * re-driving held jobs by hand. Forward, five minutes: the skew every JWT
+ * verifier already tolerates; anything further is a clock that is wrong.
+ * Outside the window the hub answers `rejected(invalid_event)` naming
+ * `occurredAt` and never clamps, so the poster refuses BEFORE posting: an
+ * event the hub would refuse on its date is held where it was made, never
+ * counted as a rejection at the hub (PRDCT-2644).
+ */
+export declare const USAGE_EVENT_MAX_PAST_MS: number;
+export declare const USAGE_EVENT_MAX_FUTURE_MS: number;
+/**
+ * Why an event's `occurredAt` is refused against the receipt time, or null
+ * when it falls inside the window (both bounds INCLUSIVE). The hub's
+ * `usageEventOccurrenceIssue`, copied (the wire snapshot's occurrence table
+ * checks it on the hub's offsets): the one comparison both
+ * halves run, the hub at ingest against its own clock, the chassis before
+ * posting against its best estimate of the receipt (its own clock), so the
+ * two never disagree on the sign or the edge.
+ */
+export declare function usageEventOccurrenceIssue(occurredAt: Date, receivedAt: Date): {
+    path: 'occurredAt';
+    message: string;
+} | null;
+/**
+ * The request of `POST /usage/check` (the hub's `UsageCheckRequest`,
+ * PRDCT-2663): the paying account, the action key and the quantity of THIS
+ * request. `unit` is accepted and ignored by the hub, which prices by its
+ * own row; it is sent so the answer's unit can be compared and a mismatch
+ * logged.
+ */
+export declare const usageCheckRequestSchema: z.ZodObject<{
+    accountRef: z.ZodUUID;
+    actionKey: z.ZodString;
+    quantity: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UsageCheckRequest = z.infer<typeof usageCheckRequestSchema>;
+/**
+ * The three reasons a check refuses (`null` when allowed), the hub's
+ * `USAGE_CHECK_REASONS`: `account_suspended` (checked first, whatever the
+ * price), `unpriceable` (the price of this quantity exceeds
+ * `Number.MAX_SAFE_INTEGER`: the hub clamps `credits` to that bound, and the
+ * ingest would reject the same event on its `quantity`) and
+ * `insufficient_credits` (`balance < credits`). Each is a refusal, never an
+ * outage (PRDCT-2677).
+ */
+export declare const USAGE_CHECK_REASONS: readonly ["insufficient_credits", "account_suspended", "unpriceable"];
+export type UsageCheckReason = (typeof USAGE_CHECK_REASONS)[number];
+/**
+ * The hub's answer to `POST /usage/check` (its `UsageCheck`, PRDCT-2663),
+ * checked against the hub's wire snapshot (PRDCT-2677): advisory, no side effect. `credits` is the price of
+ * this quantity from the price book row effective now (0 and `priced:
+ * false` when the tool has no row for the action: views are never priced,
+ * an unknown key is not a refusal); `balance` the account's; `allowed` is
+ * `balance >= credits` unless the organization is suspended, which refuses
+ * whatever the price. `topUpUrl` is always present: the hub's billing page
+ * for that organization, what a `402 entitlement_denied` carries straight
+ * off the answer. No lower bound on `quantity` or `credits`, as at the hub: a
+ * copy stricter than the hub reads a valid answer as an outage.
+ */
+export declare const usageCheckSchema: z.ZodObject<{
+    accountRef: z.ZodUUID;
+    actionKey: z.ZodString;
+    quantity: z.ZodNumber;
+    allowed: z.ZodBoolean;
+    credits: z.ZodNumber;
+    balance: z.ZodNumber;
+    unit: z.ZodNullable<z.ZodString>;
+    priced: z.ZodBoolean;
+    plan: z.ZodEnum<{
+        free: "free";
+        pro: "pro";
+    }>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        insufficient_credits: "insufficient_credits";
+        account_suspended: "account_suspended";
+        unpriceable: "unpriceable";
+    }>>;
+    topUpUrl: z.ZodString;
+}, z.core.$strip>;
+export type UsageCheck = z.infer<typeof usageCheckSchema>;
+/** The wire code of a credit refusal (§7 step 4), and its `details`. */
+export declare const ENTITLEMENT_DENIED = "entitlement_denied";
+export interface EntitlementDeniedDetails {
+    /** The price of this action, in credits. */
+    credits: number;
+    /** The organization's balance, in credits. */
+    balance: number;
+    /** The hub's billing page for the organization: where a human adds credits. */
+    topUpUrl: string;
+}
+/**
+ * What a declaration's functions see: the request as the chassis reads it.
+ * `audit` is present only AFTER the handler ran (the emit), carrying what the
+ * handler recorded for its audit row — the place a stored size or a created
+ * resource id lives.
+ */
+export interface EntitlementRequest {
+    method: string;
+    path: string;
+    headers: HeaderReader;
+    /** Route params by name (`{id}` → its value). */
+    params: Record<string, string>;
+    principal: Principal | null;
+    /**
+     * The parsed JSON body of the request, read once and shared with the
+     * handler's own validation (the server caches the parse); `undefined`
+     * when the request carries none or it does not parse (the route's
+     * validator then answers 400 itself). A count limit or a conditional
+     * feature reads what the request asks for here (PRDCT-2702): the mint
+     * of a share link with a password, the address an invitation names.
+     */
+    body: () => Promise<unknown>;
+    audit?: {
+        action: string;
+        resourceType: string;
+        resourceId?: string;
+        metadata?: Record<string, unknown>;
+    } | undefined;
+}
+/**
+ * Who pays and who is reported (§8): the organization's account pays, the
+ * user is reported. The default actor is the principal; a route on an
+ * anonymous surface resolves its resource's owner here instead (share token
+ * → deck → owner → the owner's workspace and account) — the viewer is never
+ * identified.
+ */
+export interface ActorRef {
+    /** The reported user, or null when the actor is a resource owner the tool could not name. */
+    userId: string | null;
+    workspaceId: string;
+    /** The paying account (the workspace's central account id); absent = unmetered (oss, or a cloud-local workspace). */
+    accountRef?: string | undefined;
+}
+/**
+ * The actor of a request when it is not the principal: the owner of a
+ * resource reached anonymously (a form response through a share link), or
+ * the workspace a public door opens (an invitation accepted, a collaborator
+ * grant claimed). Resolves null to leave the route to its own handling.
+ */
+export type ActorHook = (ctx: EntitlementRequest) => Promise<ActorRef | null> | ActorRef | null;
+export interface MeterDeclaration {
+    /** The action key, namespaced by the tool's price book (`things.publish`). */
+    key: string;
+    /** The unit the price is per (`call`, `bytes`, `items`). */
+    unit: string;
+    /** The quantity of this request; default 1. Called before the handler (the check) and after it (the emit, with `audit` set). */
+    quantity?: (ctx: EntitlementRequest) => number;
+    /** The actor when it is not the principal (the owner of a resource reached anonymously). */
+    actor?: ActorHook;
+}
+export interface LimitDeclaration {
+    /** The limit key (`things.maxBytes`), declared with its per-tier values in the tool's `entitlements` slot. */
+    key: string;
+    /**
+     * The value this request observes, compared against the tier's value; over
+     * it is a plan refusal. A SIZE limit reads the declared length
+     * (`declaredContentLength`, synchronous: the gate then also demands a
+     * Content-Length on a metered account). A COUNT limit (PRDCT-2702) may be
+     * asynchronous and read the body and the tool's own tables: it returns the
+     * count AFTER this action (the resource's things plus this one), so
+     * `observed > max` is the refusal, and `null` when there is nothing to
+     * judge (the resource does not resolve, the caller may not see it): the
+     * gate then lets the route answer on its own.
+     */
+    value: (ctx: EntitlementRequest) => number | null | Promise<number | null>;
+}
+/**
+ * A feature a route needs, with an optional condition on the request
+ * (PRDCT-2702): a route that creates a thing needs `things.premium` only
+ * when the body asks for the premium option, so a declaration on the route
+ * refuses the act and never the route. Absent `when`, the whole route needs
+ * the feature.
+ */
+export interface FeatureDeclaration {
+    key: string;
+    when?: (ctx: EntitlementRequest) => boolean | Promise<boolean>;
+}
+export interface RouteEntitlement {
+    meter?: MeterDeclaration | undefined;
+    limit?: LimitDeclaration | undefined;
+    /** A feature key (`things.premium`), declared with its per-tier switch in the tool's `entitlements` slot, or the key with a condition. */
+    feature?: string | FeatureDeclaration | undefined;
+    /**
+     * The actor of a route that meters nothing but checks a limit or a feature
+     * on a PUBLIC door (no principal): the workspace the door opens pays and is
+     * judged. A meter's own `actor` serves the same purpose on a metered route;
+     * this one covers the limit-only shape. Either makes the route a viewer's
+     * surface: every refusal to it is one neutral sentence.
+     */
+    actor?: ActorHook | undefined;
+}
+/** The key of a route's feature declaration, whichever shape it uses; null when none. */
+export declare function featureKeyOf(entry: RouteEntitlement): string | null;
+/** The actor hook of a route, the entry's own or its meter's; null when the principal is the actor. */
+export declare function actorHookOf(entry: RouteEntitlement): ActorHook | null;
+/** A route as the contract spells it: the OpenAPI method and the `{param}` path. */
+export interface RouteRef {
+    method: string;
+    path: string;
+}
+export interface RouteEntitlementEntry extends RouteEntitlement {
+    route: RouteRef;
+}
+/** `METHOD /path` — the registry key of a route. */
+export declare function routeEntitlementKey(route: RouteRef): string;
+export type RouteEntitlementDeclarations = ReadonlyMap<string, RouteEntitlementEntry>;
+/**
+ * Build the registry from the tool's route objects. One entry per route: a
+ * second declaration of the same route throws at module load, so a typo or a
+ * copy cannot silently double or replace a price.
+ */
+export declare function declareRouteEntitlements(entries: ReadonlyArray<RouteEntitlementEntry>): RouteEntitlementDeclarations;
+/** The declared body size of a request (its `Content-Length`), 0 when absent or malformed. */
+export declare function declaredContentLength(ctx: EntitlementRequest): number;
+/**
+ * The stored size a handler recorded in its audit metadata (`sizeBytes`),
+ * falling back to the declared body size before the handler ran. The check
+ * sees the declared size, the emit sees the bytes that were actually kept.
+ */
+export declare function auditedSizeBytes(ctx: EntitlementRequest): number;
+/**
+ * A priced action: the default the hub seeds its price book from (§7); the
+ * hub's rows win afterwards. `creditsPerUnit` credits buy `per` units of
+ * `unit` (`per` defaults to 1): an action metered in bytes and priced per
+ * mebibyte declares `{ creditsPerUnit: 5, unit: 'bytes', per: 1048576 }`,
+ * so the meter stays exact, the price reads as the seed table says it, and
+ * the two agree by construction (PRDCT-2627: the boot refuses a route whose
+ * meter unit differs from its action's). The hub prices an event as
+ * `creditsPerUnit × quantity / per`; rounding a fraction of a credit is the
+ * hub's rule, not the tool's.
+ */
+export declare const entitlementActionSchema: z.ZodObject<{
+    key: z.ZodString;
+    creditsPerUnit: z.ZodNumber;
+    unit: z.ZodString;
+    per: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type EntitlementAction = z.infer<typeof entitlementActionSchema>;
+/**
+ * The credits an action declares for a quantity: `creditsPerUnit × quantity
+ * / per`, exact (a fraction is the hub's to round). A test pins the seed
+ * values with it, so a unit slip (5 per byte where 5 per MB was meant)
+ * fails before the price book is seeded from discovery.
+ */
+export declare function declaredCredits(action: Pick<EntitlementAction, 'creditsPerUnit' | 'per'>, quantity: number): number;
+/** A limit's value per tier plus the oss value (the operator's own knob); null = unlimited. */
+export declare const tierLimitSchema: z.ZodObject<{
+    oss: z.ZodNullable<z.ZodNumber>;
+    free: z.ZodNullable<z.ZodNumber>;
+    pro: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type TierLimit = z.infer<typeof tierLimitSchema>;
+/** A feature's switch per tier (oss has every feature: a self-hosted instance knows no plan). */
+export declare const tierFeatureSchema: z.ZodObject<{
+    free: z.ZodBoolean;
+    pro: z.ZodBoolean;
+}, z.core.$strip>;
+export type TierFeature = z.infer<typeof tierFeatureSchema>;
+export declare const toolEntitlementsSchema: z.ZodObject<{
+    actions: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        creditsPerUnit: z.ZodNumber;
+        unit: z.ZodString;
+        per: z.ZodOptional<z.ZodNumber>;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    limits: z.ZodRecord<z.ZodString, z.ZodObject<{
+        oss: z.ZodNullable<z.ZodNumber>;
+        free: z.ZodNullable<z.ZodNumber>;
+        pro: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    features: z.ZodRecord<z.ZodString, z.ZodObject<{
+        free: z.ZodBoolean;
+        pro: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ToolEntitlements = z.infer<typeof toolEntitlementsSchema>;
+/**
+ * The hub's answer to `GET /usage/entitlements?accountRef=` (§5): the hub's
+ * `usageEntitlementsSchema` (PRDCT-2636), checked against the hub's wire
+ * snapshot (PRDCT-2677). The account's
+ * plan, resolved from the tier's defaults and the account's overrides; in
+ * phase 1 `limits` and `features` are empty and the tool's own declared
+ * values fill the numbers. A limit's value is a number or a boolean: the
+ * hub may switch a numeric limit off or on per account (`true` = unlimited,
+ * `false` = nothing allowed; `profiles.ts` resolves it so). Since phase 2
+ * (PRDCT-2663) the hub serves its real rows — every limit key it holds for
+ * the calling tool and the features on for the account — and `upgradeUrl`,
+ * its upgrade page for the organization carrying `org`, `tool` and `plan`;
+ * the chassis appends `&key=<key>&requiredPlan=<tier>` at refusal time.
+ * Required: every hub since 0.11.0 sends it.
+ */
+export declare const entitlementProfileSchema: z.ZodObject<{
+    accountRef: z.ZodUUID;
+    plan: z.ZodEnum<{
+        free: "free";
+        pro: "pro";
+    }>;
+    planUntil: z.ZodNullable<z.ZodString>;
+    limits: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean]>>;
+    features: z.ZodArray<z.ZodString>;
+    upgradeUrl: z.ZodString;
+}, z.core.$strip>;
+export type EntitlementProfile = z.infer<typeof entitlementProfileSchema>;
+/** The wire code of a plan refusal, and its `details` (§7 step 2). */
+export declare const PLAN_REQUIRED = "plan_required";
+export interface PlanRequiredDetails {
+    key: string;
+    plan: EntitlementTier;
+    /** The first tier that allows the action, or null when none does. */
+    requiredPlan: EntitlementTier | null;
+    upgradeUrl: string;
+}
+//# sourceMappingURL=entitlements.d.ts.map

package/dist/entitlements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entitlements.d.ts","sourceRoot":"","sources":["../src/entitlements.ts"],"names":[],"mappings":"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"}