@plitzi/sdk-server 0.32.24 → 0.33.0

package/dist/src/modules/mcp/types/aiSchema.d.ts

@@ -1,218 +0,0 @@
-import { Environment } from '@plitzi/sdk-shared';
-export type Env = Environment;
-/** CSS declarations for one selector state. Keys are kebab-case CSS properties (see plitzi://css-properties). */
-export type CssProps = Record<string, string | number>;
-export interface DisplayModeCss {
-    desktop?: CssProps;
-    tablet?: CssProps;
-    mobile?: CssProps;
-}
-export interface ResourceEnvelope<T> {
-    stateVersion: string;
-    data: T;
-}
-/**
- * Read projections follow a filesystem model: list cheap summaries/skeletons, then read one element's detail
- * on demand. Heavy per-element data (props, style) lives only in AIElementDetail, never in the listings.
- */
-export interface AIPageSummary {
-    ref: string;
-    label: string;
-    slug: string;
-    default: boolean;
-    /** Whether the page is served by the published SDK runtime. A disabled page (`false`) is not routable/accessible
-     *  to end users, but stays fully editable here. Defaults to true. */
-    enabled: boolean;
-    /** The ref of the folder this page lives in (a PageFolder id), or undefined for a root-level page. */
-    folder?: string;
-    elementCount: number;
-}
-/** A page folder in the sidebar tree. `ref` is the folder's id (there is no separate idRef); pages reference it
- *  by that id via their `folder`, and nested folders via `parentId`. */
-export interface AIFolder {
-    ref: string;
-    name: string;
-    slug: string;
-    parentId?: string;
-}
-export interface AISkeletonNode {
-    ref: string;
-    type: string;
-    label: string;
-    subType?: string;
-    /** This element's version — identical to the stateVersion a direct element read or search hit returns for it. Diff
-     *  it against a version you already hold to re-read (plitzi_read) only the nodes that actually changed. */
-    stateVersion?: string;
-    /** The class refs this node attaches on its base selector — names only, no CSS. Lets an agent map element →
-     *  class straight from the page skeleton, without a per-element read just to learn which class it uses. */
-    base?: string[];
-    /** Class refs attached on non-base slots (slot → class refs), names only. */
-    slots?: Record<string, string[]>;
-    childCount: number;
-    children?: AISkeletonNode[];
-}
-export interface AIPageSkeleton {
-    ref: string;
-    label: string;
-    slug: string;
-    default: boolean;
-    /** Whether the page is served by the published SDK runtime. A disabled page (`false`) is not routable/accessible
-     *  to end users, but stays fully editable here. Defaults to true. */
-    enabled: boolean;
-    /** Route params bound by the slug (e.g. ":spaceId" → ["spaceId"]). Valid as {{name}} references on this page,
-     *  alongside the space-level plitzi://schema-variables. */
-    routeParams: string[];
-    tree: AISkeletonNode[];
-}
-/** Every style a page uses in one payload: the class definitions its elements attach (deduplicated, with CSS)
- *  and the global element selectors that affect any element type present on the page. Collapses "what styles
- *  does this page use" to a single read, with no reliance on a shared class-naming prefix. */
-export interface AIPageStyles {
-    ref: string;
-    definitions: AIDefinition[];
-    globalStyles: AIGlobalStyle[];
-}
-/** Which variant each attached class/selector currently uses on this element (element.definition.initialState
- *  .styleVariant). Outer key = class ref, inner key = selector (`base` or a slot), value = variant name(s). */
-export type AIStyleVariantSelection = Record<string, Record<string, string | string[]>>;
-/** The element's initial (default) state overrides. `styleVariant` picks which variant of its classes is active;
- *  `visibility` hides/shows it initially. Kept minimal — the two fields agents actually set. */
-export interface AIInitialState {
-    styleVariant?: AIStyleVariantSelection;
-    visibility?: boolean;
-}
-/** One data binding: connect a data `source` to the element field named by `to` (a prop, a style value, or an
- *  initial-state key, per its category). `transformers` reshape the value; `when` gates the binding. */
-export interface AIBinding {
-    id: string;
-    to: string;
-    source: string;
-    transformers?: Array<{
-        action: string;
-        params: Record<string, string>;
-        enabled?: boolean;
-    }>;
-    when?: unknown;
-    enabled?: boolean;
-}
-/** Data bindings on an element, grouped by what they feed: element props (`attributes`), style values (`style`),
- *  or initial-state keys (`initialState`). */
-export type AIBindings = Partial<Record<'attributes' | 'style' | 'initialState', AIBinding[]>>;
-export type AIInteractionNodeType = 'trigger' | 'globalCallback' | 'callback' | 'utility';
-/** One step of an interaction flow, projected from the stored doubly-linked node. Order is conveyed by the
- *  position in `AIInteractionFlow.nodes`; the stored beforeNode/afterNode/flowId links are computed on write. */
-export interface AIInteractionNode {
-    id: string;
-    title: string;
-    nodeType: AIInteractionNodeType;
-    action: string;
-    params?: Record<string, unknown>;
-    enabled?: boolean;
-    when?: unknown;
-    /** Source element the callback targets (globalCallback/utility). Defaults to this element on write. */
-    elementId?: string;
-    preview?: Record<string, unknown>;
-}
-/** One interaction flow on an element: a trigger (first node) followed by the callbacks/utilities it runs, in
- *  order. `flowId` equals the trigger node id. */
-export interface AIInteractionFlow {
-    flowId: string;
-    nodes: AIInteractionNode[];
-}
-export interface AIElementDetail {
-    ref: string;
-    type: string;
-    subType?: string;
-    label: string;
-    pageRef: string;
-    parentRef?: string;
-    props?: Record<string, unknown>;
-    style: {
-        base: string[];
-        slots: Record<string, string[]>;
-    };
-    /** CSS of the definitions referenced by `style` (keyed by class ref), inlined so an edit needs no follow-up
-     *  read of each definition. Present only for refs that resolve to a definition. */
-    resolvedStyle?: Record<string, AIDefinition>;
-    /** Global (type 'element') styles that also affect this element because they target its type — every element of
-     *  the type inherits them. Read-only here (not editable as definitions); shown so the effective CSS is complete. */
-    globalStyles?: AIGlobalStyle[];
-    /** Id rule (type 'id') targeting this element by its DOM `id` attribute (`#id`). Present only when the element
-     *  carries an `id` that a rule matches. Edit it with the id-style tools (never as a definition). */
-    idStyle?: AIIdStyle;
-    /** Variant names each attached class exposes (deduped across its selectors), so the agent knows a class HAS a
-     *  variant (e.g. a button class with "primary") before applying it via `initialState.styleVariant`. */
-    availableVariants?: Record<string, string[]>;
-    /** Which variant/visibility this element applies today (element.definition.initialState). */
-    initialState?: AIInitialState;
-    /** Data bindings on this element, grouped by category. */
-    bindings?: AIBindings;
-    /** Interaction flows on this element (event → ordered callbacks). */
-    interactions?: AIInteractionFlow[];
-    childRefs?: string[];
-}
-/** A global element style (a type 'element' StyleItem): its CSS applies to every element whose type equals
- *  `appliesToType`. It is not an addressable class definition — editing it would change every such element. */
-export interface AIGlobalStyle extends AIDefinition {
-    appliesToType: string;
-}
-/** An id rule (a type 'id' StyleItem): its CSS targets the single element whose DOM `id` equals `targetId`
- *  (the CSS equivalent of `#id { … }`). Style one element by giving it an `id` attribute and writing this rule;
- *  prefer a class definition when the styling could be reused. */
-export interface AIIdStyle extends AIDefinition {
-    targetId: string;
-}
-export interface AIDefinitionSlot extends DisplayModeCss {
-    states?: Record<string, DisplayModeCss>;
-    variants?: Record<string, DisplayModeCss>;
-}
-export interface AIDefinition extends AIDefinitionSlot {
-    ref: string;
-    slots?: Record<string, AIDefinitionSlot>;
-}
-export type StyleVariableCategory = 'color' | 'spacing' | 'shadow' | 'custom';
-export type StyleVariableValue = string | number | {
-    light?: string;
-    dark?: string;
-    default?: string;
-};
-export interface AIStyleVariable {
-    name: string;
-    reference: string;
-    value: StyleVariableValue;
-}
-export interface AISchemaVariable {
-    name: string;
-    reference: string;
-    category: string;
-    type: string;
-    value: string | number | boolean;
-    subValues?: Array<{
-        when: unknown;
-        value: string | number | boolean;
-    }>;
-}
-/** Space-level settings: the arbitrary global CSS (`customCss`), state persistence, and the user/auth provider
- *  configuration. Every field is optional — a patch changes only the keys it sends. */
-export interface AISettings {
-    customCss?: string;
-    keepState?: boolean;
-    stateStorage?: 'localStorage' | 'sessionStorage';
-    userProvider?: 'auth0' | 'basic' | 'custom' | '';
-    auth0Domain?: string;
-    auth0ClientId?: string;
-    tokenStorage?: 'localStorage' | 'sessionStorage' | '';
-    loginUrl?: string;
-    userUrl?: string;
-    refreshUrl?: string;
-    logoutUrl?: string;
-    detailsPath?: string;
-    tokenPath?: string;
-    expirationTimePath?: string;
-}
-export interface ValidationError {
-    path: string;
-    message: string;
-    hint: string;
-    validValues?: unknown[];
-}

package/dist/src/modules/mcp/types/appTypes.d.ts

@@ -1,26 +0,0 @@
-import { McpUiResourceCsp } from '@modelcontextprotocol/ext-apps';
-/** A `ui://` page the host renders in a sandboxed iframe, linked from a tool through `_meta.ui.resourceUri`. */
-export interface McpApp {
-    uri: string;
-    name: string;
-    description: string;
-    title: string;
-    /** Absolute path to the view: the app's browser entry. */
-    entry: string;
-    /** CSS to inline in the page, in order. Lazy, and the app produces the text itself: what a view needs is not
-     *  always a file as it sits on disk (the render app leaves the icon fonts out of its stylesheet). */
-    styles?: () => string[];
-    csp?: McpUiResourceCsp;
-}
-/** Deployment switches the page hands to the view. They travel in the HTML rather than the bundle so a server
- *  that serves both settings still builds the (expensive) browser bundle once. The view reads them off
- *  `window.__PLITZI_VIEW__`, and must treat every one as optional: an older page carries none. */
-export interface McpViewSettings {
-    /** May the view paint from tool arguments the host is still streaming? See `mcpAi.renderStreaming`. */
-    streaming: boolean;
-    /** Absolute resource endpoint of the server that served the page, when it serves one (see `mcpAi.proxy`). It
-     *  shapes the PAGE rather than the view: its origin is what the resource CSP declares, so the URLs a render
-     *  rewrote to it are allowed to load. The view needs nothing from it — every URL is rewritten server-side,
-     *  where the signing secret is. */
-    proxyEndpoint?: string;
-}

package/dist/src/modules/mcp/types/index.d.ts

@@ -1,5 +0,0 @@
-export type * from './aiSchema';
-export type * from './appTypes';
-export type * from './toolTypes';
-export type * from './previewTypes';
-export type * from './screenshotTypes';

package/dist/src/modules/mcp/types/previewTypes.d.ts

@@ -1,25 +0,0 @@
-import { ValidationError } from './aiSchema';
-import { Operation } from '../tools/operations';
-export type PreviewRequestBody = {
-    spaceId: number;
-    env?: string;
-    pageRef?: string;
-    operations?: Operation[];
-};
-export type PreviewResult = {
-    ok: true;
-    token?: string;
-    pagePath: string;
-    html: string;
-    stateVersion: string;
-} | {
-    ok: false;
-    error: string;
-    message: string;
-    errors?: ValidationError[];
-};
-/** How the MCP tools reach the renderer. The consumer injects an implementation (an HTTP client to the SSR
- *  `/preview` endpoint, or an in-process call when co-located); absent means preview is not wired. */
-export type PreviewClient = {
-    render: (body: PreviewRequestBody) => Promise<PreviewResult>;
-};

package/dist/src/modules/mcp/types/screenshotTypes.d.ts

@@ -1,29 +0,0 @@
-export type Viewport = {
-    label: string;
-    width: number;
-    height: number;
-};
-export type ScreenshotImage = {
-    label: string;
-    mimeType: string;
-    data: string;
-};
-export type ScreenshotResult = {
-    ok: true;
-    images: ScreenshotImage[];
-} | {
-    ok: false;
-    error: string;
-    message: string;
-};
-export type ScreenshotInput = {
-    pagePath: string;
-    token?: string;
-    viewports: Viewport[];
-};
-/** How plitzi_screenshot reaches the headless-browser service. The consumer injects an implementation (an HTTP
- *  client to the dedicated browser pod); absent → the tool is not registered. A capture that fails (pod down)
- *  returns `ok:false` rather than throwing, so the tool can degrade to the HTML preview. */
-export type ScreenshotClient = {
-    capture: (input: ScreenshotInput) => Promise<ScreenshotResult>;
-};

package/dist/src/modules/mcp/types/toolTypes.d.ts

@@ -1,138 +0,0 @@
-import { AIDefinition, AIElementDetail, ValidationError } from './aiSchema';
-import { Operation } from '../tools/operations';
-import { Schema, Style } from '@plitzi/sdk-shared';
-/** The element schema and the style schema persist independently (Space model / Style model), so each has
- *  its own optional persister. When one is absent, that schema is applied in memory but reported unsaved. */
-export interface Persisters {
-    schema?: (schema: Schema) => Promise<void>;
-    style?: (style: Style) => Promise<void>;
-}
-export interface Conflict {
-    resourceUri: string;
-    expectedVersion: string;
-    currentVersion: string;
-}
-export interface ChangedResource {
-    uri: string;
-    stateVersion: string;
-}
-/** Full detail of a created/updated element, plus its own uri and stateVersion so a follow-up edit of the same
- *  element can guard with optimistic concurrency without an intermediate read. */
-export type WriteElement = AIElementDetail & {
-    uri: string;
-    stateVersion: string;
-};
-/** Write result: what changed and the new versions, plus the full detail of every element created/updated (with
- *  its uri + stateVersion) so the caller has that context without a follow-up read. Other resources (pages,
- *  definitions, variables) still report only uri+version — re-read them if needed. */
-export interface WriteResponse {
-    applied: boolean;
-    dryRun?: boolean;
-    persisted?: boolean;
-    summary: {
-        created: number;
-        updated: number;
-        deleted: number;
-    };
-    changed: ChangedResource[];
-    elements?: WriteElement[];
-    warnings?: string[];
-    errors?: ValidationError[];
-    conflict?: {
-        message: string;
-        conflicts: Conflict[];
-    };
-}
-/** The outcome of applying a batch to the space in memory: counts, which schema(s) changed (so the caller can
- *  persist each independently), the invalidated resource URIs and the refs of the elements it created/updated. */
-export interface MutationOutcome {
-    created: number;
-    updated: number;
-    deleted: number;
-    staleResources: string[];
-    elementRefs: string[];
-    errors: ValidationError[];
-    changedSchema: boolean;
-    changedStyle: boolean;
-}
-export interface ApplyInput {
-    environment?: string;
-    dryRun?: boolean;
-    expectedResourceVersions?: Record<string, string>;
-    operations: Operation[];
-}
-export interface ValidateInput {
-    environment?: string;
-    operations: Operation[];
-}
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: string[];
-}
-export interface SearchInput {
-    query: string;
-    filters?: {
-        type?: string;
-        pageRef?: string;
-    };
-    /** 'detail' inlines each hit's full props/style so an edit needs no follow-up read. */
-    include?: 'detail';
-    /** Max element hits to return in this page (default 50). */
-    limit?: number;
-    /** Element hits to skip before this page (default 0). */
-    offset?: number;
-}
-export interface SearchHit {
-    pageRef: string;
-    ref: string;
-    uri: string;
-    pageUri: string;
-    stateVersion: string;
-    parentRef?: string;
-    /** Ancestor labels from the page down to and including this element. */
-    path: string[];
-    label: string;
-    type: string;
-    matches: string[];
-    detail?: AIElementDetail;
-}
-export interface SearchPageHit {
-    ref: string;
-    uri: string;
-    stateVersion: string;
-    label: string;
-    slug: string;
-    matches: string[];
-}
-export interface SearchResponse {
-    results: SearchHit[];
-    /** Total element hits matching the query across all pages, before offset/limit. */
-    total: number;
-    /** Element hits skipped before this page (echoes the request's offset, defaulted). */
-    offset: number;
-    /** Page size applied to element hits (echoes the request's limit, defaulted). */
-    limit: number;
-    /** The offset to pass next to fetch the following page. Present only while more hits remain past this page. */
-    nextOffset?: number;
-    /** Style definitions whose ref matches the query, with their full CSS — so finding a class by name closes the
-     *  loop to its style without a separate read. Present only when at least one definition matches. */
-    definitions?: AIDefinition[];
-    /** Pages whose name or slug matches the query (element hits never include pages). Each carries the page uri +
-     *  stateVersion, ready to open or edit. Present only when at least one page matches. */
-    pages?: SearchPageHit[];
-}
-export interface ReadInput {
-    uris: string[];
-}
-export interface ReadHit {
-    uri: string;
-    stateVersion?: string;
-    data?: unknown;
-    error?: string;
-    message?: string;
-    hint?: string;
-}
-export interface ReadResponse {
-    results: ReadHit[];
-}

package/dist/src/modules/oauth/authorize.d.ts

@@ -1,7 +0,0 @@
-import { OAuthParams } from './params';
-import { OAuthConfig, SSRResponseHelpers } from '@plitzi/sdk-shared';
-/** GET /authorize — the entry point a host opens in the user's browser. */
-export declare const handleAuthorizeStart: (config: OAuthConfig, res: SSRResponseHelpers, params: OAuthParams) => Promise<void>;
-/** POST /authorize — both steps of the form land here: the credentials submit, and the grant submit that carries
- *  the `pending` id proving the credentials step already passed. */
-export declare const handleAuthorizeSubmit: (config: OAuthConfig, res: SSRResponseHelpers, params: OAuthParams) => Promise<void>;

package/dist/src/modules/oauth/challenge.d.ts

@@ -1,11 +0,0 @@
-import { OAuthConfig, SSRRequest, SSRResponseHelpers } from '@plitzi/sdk-shared';
-/** The credential on an MCP request. `Authorization: Bearer` is what RFC 6750 defines and what a remote host
- *  sends; `x-access-token` is the platform's own header, which the builder and the CLI already use — a request
- *  carrying either presents a credential, and the same verification decides whether it is a good one. */
-export declare const bearerOf: (req: SSRRequest) => string;
-/** RFC 6750 §3 — the answer to an MCP request that presents no usable credential, and the only thing that starts
- *  an authorization flow: a host runs OAuth off a 401 whose `WWW-Authenticate` names the resource metadata, and
- *  IGNORES the header on a 200. Answering such a request with the anonymous surface instead is what leaves a
- *  connector unable to attach the grant it just completed — the flow succeeds and the host still reports that
- *  authorization failed. `scope` states what to ask for, so consent is not widened to everything advertised. */
-export declare const sendChallenge: (config: OAuthConfig, req: SSRRequest, res: SSRResponseHelpers, description: string) => void;

package/dist/src/modules/oauth/consentPage.d.ts

@@ -1,7 +0,0 @@
-import { OAuthConsentView } from '@plitzi/sdk-shared';
-/** The built-in consent screen: a credentials step, then a step to pick what the client gets access to. Replace it
- *  wholesale via `oauth.renderConsent` — the field names read back here are the contract, not the markup. */
-export declare const renderConsentPage: (view: OAuthConsentView) => string;
-/** The dead end for a request that cannot be redirected back — a bad `redirect_uri` or an unknown client. Bouncing
- *  those to the client would make this server an open redirector, so the user is told here instead. */
-export declare const renderErrorPage: (title: string, detail: string) => string;

package/dist/src/modules/oauth/metadata.d.ts

@@ -1,40 +0,0 @@
-import { OAuthConfig, SSRRequest } from '@plitzi/sdk-shared';
-export declare const AUTHORIZE_PATH = "/authorize";
-export declare const TOKEN_PATH = "/token";
-export declare const REGISTER_PATH = "/register";
-export declare const PROTECTED_RESOURCE_PATH = "/.well-known/oauth-protected-resource";
-export declare const AUTHORIZATION_SERVER_PATH = "/.well-known/oauth-authorization-server";
-/** The identifier the two documents agree on. This server is both the protected resource and its own
- *  authorization server, so one origin names both. Derived from the request unless pinned, which keeps a
- *  deployment correct across its dev, staging and production hosts without per-environment config. */
-export declare const issuerOf: (config: OAuthConfig, req: SSRRequest) => string;
-export declare const scopesOf: (config: OAuthConfig) => string[];
-/** Where the challenge points a host, for an MCP endpoint served at `req.path`. RFC 9728 §3.1 appends the
- *  resource's own path to the well-known path, and a host that reads the document back expects its `resource` to
- *  name the URL it was configured with — so a server mounted at /mcp must be pointed at the suffixed document,
- *  not the bare one. */
-export declare const resourceMetadataUrl: (config: OAuthConfig, req: SSRRequest) => string;
-/** RFC 9728. The document Claude Desktop asks for FIRST, and the one whose absence ends the flow before anything
- *  else is tried — a 404 here is what a host reports as `mcp_auth_start_failed`.
- *
- *  `resource` echoes the path the document was asked for: Claude requires it to match the server URL the user
- *  typed, path included, and a dedicated MCP server answers JSON-RPC on every path — so `/.well-known/…/mcp`
- *  describes `https://host/mcp` while the bare path describes the origin.
- *
- *  A server mounted at the ORIGIN is `https://host/`, WITH the trailing slash: a host parses the URL the user
- *  typed before it does anything with it, and an empty path renders as `/` — Claude's connector was observed
- *  asking for exactly `resource=https%3A%2F%2Fhost%2F`, so that is the form the document must claim.
- *
- *  It does NOT make a bare-origin connector work, and nothing here can. Claude's remote-connector service will
- *  not open a session against an MCP endpoint whose URL has no path: the whole grant succeeds — discovery,
- *  registration, consent, a 200 from /token with the scope it asked for — and then it reports
- *  `McpAuthorizationError` ("the integration rejected the credentials it just issued") without ever presenting
- *  the bearer. Verified against the same deployment, minutes apart: at /mcp the token is followed by
- *  `initialize`, at / nothing follows it, in the ingress log as well as this server's. Claiming `https://host/mcp`
- *  from the bare document would only fail sooner — a client checks that the resource it is handed is no MORE
- *  specific than the URL it holds. Publish the connector URL WITH its path. */
-export declare const protectedResourceMetadata: (config: OAuthConfig, req: SSRRequest) => Record<string, unknown>;
-/** RFC 8414. Public clients with PKCE only: a desktop host stores no secret, so `none` is the sole endpoint auth
- *  method and S256 the sole challenge method. `offline_access` is advertised whenever refresh grants are issued,
- *  which is the signal a host looks for before asking for one. */
-export declare const authorizationServerMetadata: (config: OAuthConfig, req: SSRRequest) => Record<string, unknown>;

package/dist/src/modules/oauth/params.d.ts

@@ -1,5 +0,0 @@
-/** Query-string or form fields as they arrive from a client: every name is optional, and an absent one is not
- *  distinguishable from an empty one — both mean "the client did not send this". */
-export type OAuthParams = Record<string, string | undefined>;
-export declare const field: (params: OAuthParams, name: string) => string;
-export declare const optionalField: (params: OAuthParams, name: string) => string | undefined;

package/dist/src/modules/oauth/pkce.d.ts

@@ -1,6 +0,0 @@
-/** An unguessable, URL-safe identifier for the values this layer hands out (codes, refresh tokens, client ids).
- *  256 bits from the CSPRNG, so they are also unguessable by anyone who collects a few of them. */
-export declare const randomId: () => string;
-/** RFC 7636 S256, the only method this server accepts — `plain` puts the verifier on the wire, and a public
- *  client on a desktop host has no other proof it is the one that started the flow. */
-export declare const verifyChallenge: (verifier: string, challenge: string) => boolean;

package/dist/src/modules/oauth/records.d.ts

@@ -1,71 +0,0 @@
-import { OAuthGrantTarget, OAuthStore, OAuthUser } from '@plitzi/sdk-shared';
-/** A client that registered itself through RFC 7591. Public clients only — a desktop host cannot keep a secret,
- *  so the token endpoint authenticates the exchange with PKCE instead. */
-export type ClientRecord = {
-    clientId: string;
-    clientName: string;
-    redirectUris: string[];
-    /** When this registration was first handed out, so re-registering the same client keeps reporting its real age. */
-    issuedAt: number;
-};
-/** The authorization request, parked while the user logs in. `challenge` binds the eventual code to the client
- *  that started the flow. */
-export type PendingRecord = {
-    clientId: string;
-    redirectUri: string;
-    challenge: string;
-    state?: string;
-    scope?: string;
-    user: OAuthUser;
-};
-/** A code, redeemable once, for the token it already resolves to. Minting the bearer at consent time (rather than
- *  at redemption) means a failure the user could act on — no space, revoked access — surfaces on the consent
- *  screen instead of as an opaque `invalid_grant` inside the host. */
-export type CodeRecord = {
-    clientId: string;
-    redirectUri: string;
-    challenge: string;
-    token: string;
-    expiresInSeconds?: number;
-    scope?: string;
-    user: OAuthUser;
-    target: OAuthGrantTarget;
-};
-/** A refresh grant: everything needed to mint a fresh bearer without asking the user again. */
-export type RefreshRecord = {
-    clientId: string;
-    scope?: string;
-    user: OAuthUser;
-    target: OAuthGrantTarget;
-};
-/** A bearer this server handed out. The token a client holds is an opaque handle minted here, and this record is
- *  what it stands for — including `credential`, the thing the deployment's own adapters understand, which never
- *  leaves the server: a platform token is usually good against more than the MCP endpoint, and a remote host has
- *  no business holding one. The record expires with the bearer, which is what turns an expired one into the 401 a
- *  host answers by refreshing; dropping it early revokes the bearer outright. */
-export type AccessRecord = {
-    /** What {@link OAuthAdapters.issueToken} returned — swapped back onto the request once the bearer checks out.
-     *  Absent only in a record written before the bearer and the credential were separate things, where the bearer
-     *  WAS the credential: a live connector must survive that upgrade, so the reader falls back to the token itself. */
-    credential?: string;
-    clientId: string;
-    user: OAuthUser;
-    target: OAuthGrantTarget;
-};
-export declare const putClient: (store: OAuthStore, client: ClientRecord) => Promise<void>;
-export declare const getClient: (store: OAuthStore, clientId: string) => Promise<ClientRecord | undefined>;
-/** The id already handed out for an identical registration. Keyed by what the client asked to be registered AS,
- *  so the same request always resolves to the same client — see handleRegister for why that matters. */
-export declare const getClientByFingerprint: (store: OAuthStore, fingerprint: string) => Promise<ClientRecord | undefined>;
-export declare const putClientFingerprint: (store: OAuthStore, fingerprint: string, clientId: string) => Promise<void>;
-export declare const putPending: (store: OAuthStore, id: string, pending: PendingRecord) => Promise<void>;
-export declare const getPending: (store: OAuthStore, id: string) => Promise<PendingRecord | undefined>;
-export declare const dropPending: (store: OAuthStore, id: string) => Promise<void>;
-export declare const putCode: (store: OAuthStore, code: string, record: CodeRecord, ttlSeconds: number) => Promise<void>;
-export declare const getCode: (store: OAuthStore, code: string) => Promise<CodeRecord | undefined>;
-export declare const dropCode: (store: OAuthStore, code: string) => Promise<void>;
-export declare const putRefresh: (store: OAuthStore, token: string, record: RefreshRecord, ttlSeconds: number) => Promise<void>;
-export declare const getRefresh: (store: OAuthStore, token: string) => Promise<RefreshRecord | undefined>;
-export declare const dropRefresh: (store: OAuthStore, token: string) => Promise<void>;
-export declare const putAccess: (store: OAuthStore, token: string, record: AccessRecord, ttlSeconds: number) => Promise<void>;
-export declare const getAccess: (store: OAuthStore, token: string) => Promise<AccessRecord | undefined>;

package/dist/src/modules/oauth/register.d.ts

@@ -1,5 +0,0 @@
-import { OAuthConfig, SSRResponseHelpers } from '@plitzi/sdk-shared';
-/** RFC 7591 dynamic client registration. A remote host has no way to be configured into this server ahead of
- *  time, so it registers itself on first connect; the record it gets back is only ever used to pin the redirect
- *  target, since a public client authenticates with PKCE rather than with credentials. */
-export declare const handleRegister: (config: OAuthConfig, res: SSRResponseHelpers, body: unknown) => Promise<void>;

package/dist/src/modules/oauth/respond.d.ts

@@ -1,13 +0,0 @@
-import { SSRResponseHelpers } from '@plitzi/sdk-shared';
-/** The error codes RFC 6749 defines for the responses this server produces. */
-export type OAuthErrorCode = 'invalid_request' | 'invalid_client' | 'invalid_grant' | 'unauthorized_client' | 'unsupported_grant_type' | 'unsupported_response_type' | 'invalid_scope' | 'access_denied' | 'server_error';
-export declare const sendJson: (res: SSRResponseHelpers, status: number, body: unknown) => void;
-export declare const sendHtml: (res: SSRResponseHelpers, status: number, html: string) => void;
-export declare const sendErrorJson: (res: SSRResponseHelpers, status: number, error: OAuthErrorCode, description: string) => void;
-/** Shown when the authorization request itself is unusable — an unknown client, a `redirect_uri` that is not
- *  registered. Redirecting those back would turn the endpoint into an open redirector. */
-export declare const sendErrorPage: (res: SSRResponseHelpers, title: string, detail: string) => void;
-/** The other half of RFC 6749 error handling: once the redirect target is known to be legitimate, failures go
- *  back to the client so the host can report them, carrying `state` so it can match the response to its request. */
-export declare const redirectWithError: (res: SSRResponseHelpers, redirectUri: string, error: OAuthErrorCode, description: string, state?: string) => void;
-export declare const redirectWithCode: (res: SSRResponseHelpers, redirectUri: string, code: string, state?: string) => void;

package/dist/src/modules/oauth/token.d.ts

@@ -1,5 +0,0 @@
-import { OAuthParams } from './params';
-import { OAuthConfig, SSRResponseHelpers } from '@plitzi/sdk-shared';
-/** POST /token. Public clients only, so there is no client authentication to check — PKCE is what proves the
- *  caller is the one that started the flow. */
-export declare const handleToken: (config: OAuthConfig, res: SSRResponseHelpers, params: OAuthParams) => Promise<void>;

package/dist/src/modules/ssr/buildBody.d.ts

@@ -1,9 +0,0 @@
-import { TtlCache } from '../../helpers/cache';
-import { RequestMetrics } from '../../helpers/metrics';
-import { PluginManager } from '../../plugins/manager';
-import { Environment, OfflineDataRaw, SSRRenderResult, SSRRequest, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
-export type BuildBodyResult = {
-    body?: string;
-    result: SSRRenderResult;
-};
-export declare const buildBody: (req: SSRRequest, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, renderFn: SSRTemplateFn, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<BuildBodyResult>;

package/dist/src/modules/ssr/handler.d.ts

@@ -1,4 +0,0 @@
-import { ServerCaches } from '../../helpers/cache';
-import { PluginManager } from '../../plugins/manager';
-import { SSRRequest, SSRResponseHelpers, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
-export declare const renderSSR: (req: SSRRequest, res: SSRResponseHelpers, config: SSRServerConfig, renderFn: SSRTemplateFn, pluginManager: PluginManager, caches: ServerCaches) => Promise<void>;