@north-light/api 0.0.0 → 0.3.415

package/dist/api/dto/health.d.ts

@@ -0,0 +1,116 @@
+import type { NodeStatusDTO } from './common.js';
+/** Ephemeral daemon lifecycle phase reported by health and status. */
+export type StartupPhaseDTO = 'initializing' | 'blocked' | 'prepared' | 'recovering' | 'ready';
+/** `GET /healthz` — substrate readiness probe. Versions are informational, never
+ *  a gate. Used by the provisioning ladder. */
+export interface HealthDTO {
+    ok: boolean;
+    daemon_up: boolean;
+    store_accessible: boolean;
+    brokers_reconciled: boolean;
+    /** Present while corpus migration or normal daemon startup is incomplete. */
+    startup_blocked?: string;
+    /** Always present; only `ready` admits normal daemon work. */
+    startup_phase: StartupPhaseDTO;
+}
+/** `GET /v1/status` — daemon status snapshot. Backs `crtr sys daemon status`
+ *  state and the `crtr canvas dashboard` header. `runtime_version` is also
+ *  checked by Core's minimum-runtime capability gate. */
+export interface StatusDTO {
+    daemon_pid: number;
+    tick_interval_ms: number;
+    /** Node counts keyed by status. */
+    node_counts: Partial<Record<NodeStatusDTO, number>>;
+    /** Nodes genuinely mid-turn: their busy marker exists and their recorded pid is alive. Unlike `node_counts.active`, this excludes live-but-waiting, parked, or blocked engines. */
+    busy_node_count: number;
+    /** Bound listener addresses. `tcp` is null when the TCP listener is off. */
+    listeners: {
+        socket_path: string;
+        tcp: string | null;
+    };
+    runtime_version: string;
+    api_version: string;
+    /** Always present; only `ready` admits normal daemon work. */
+    startup_phase: StartupPhaseDTO;
+}
+/** `GET /v1/due` — whether this runtime has work in flight or due, and when its
+ *  next timed work is. `busy` is true while a non-spare node is mid-turn with a
+ *  live pid, a cron or bash job is running, or any timed lane has work due now.
+ *  `next_due_at` (ISO) is the earliest time any timed lane owes work, null when
+ *  none. A sandbox may sleep only while `busy` is false and must wake by
+ *  `next_due_at`. */
+export interface DueDTO {
+    busy: boolean;
+    next_due_at: string | null;
+}
+/** `POST /v1/daemon/restart` — the ack for a daemon-owned handover.
+ *
+ *  The daemon answers BEFORE it tears anything down: the caller is normally a
+ *  node's own bash tool, whose broker this handover will kill, so the ack must
+ *  be a settled tool result in that node's transcript before the SIGTERM lands.
+ *  `accepted` is therefore a promise about the future, not a completed action —
+ *  the successor daemon is spawned after `grace_ms`, and every node the
+ *  teardown interrupts is resumed by it. */
+export interface MigrateStateRequest {
+    dry_run?: boolean;
+}
+/** `crtr sys migrate`: the canvas import (004-canvas-documents) plan or result. */
+export interface MigrateStateDTO {
+    /** Loose-key moves/imports (paths and names only). */
+    loose_keys?: string[];
+    /** Every store root the import found, with its owner and document count. */
+    stores: {
+        root: string;
+        owner: Record<string, unknown>;
+        docs: number;
+        skipped?: string;
+    }[];
+    /** `documents.<kind>`, `documents.owner.<type>`, `revisions`, `documents.rewritten`, `owners`, … */
+    counts: Record<string, number>;
+    rewrites: {
+        path: string;
+        from: string;
+        to: string;
+    }[];
+    dropped_fields: {
+        path: string;
+        field: string;
+    }[];
+    skipped: {
+        path: string;
+        reason: string;
+    }[];
+    /** Each clash or unreadable source the import resolved itself, one line each. */
+    resolutions: {
+        kind: string;
+        message: string;
+        paths: string[];
+    }[];
+    blockers: {
+        kind: string;
+        message: string;
+        paths: string[];
+    }[];
+    dryRun: boolean;
+    /** True while the import has not been written. */
+    pending: boolean;
+    resumed: boolean;
+    resume_error?: string;
+}
+/** `POST /v1/daemon/admit` — opens normal daemon work after preparation. */
+export interface DaemonAdmitDTO {
+    /** True only for the request that began admission. */
+    admitted: boolean;
+    /** True when another request had already begun or completed admission. */
+    already_admitted: boolean;
+    startup_phase: StartupPhaseDTO;
+}
+export interface DaemonRestartDTO {
+    accepted: boolean;
+    /** The daemon that took the request and is about to hand over. */
+    predecessor_pid: number;
+    /** Its epoch id — the successor mints a new one. */
+    predecessor_epoch: string;
+    /** How long the daemon waits after answering before teardown begins. */
+    grace_ms: number;
+}

package/dist/api/dto/health.js

@@ -0,0 +1,2 @@
+// Health / status DTOs (spec §6.1).
+export {};

package/dist/api/dto/human-requests.d.ts

@@ -0,0 +1,113 @@
+import type { IsoTime } from './common.js';
+import type { InboxPageDTO, PageResponsesDTO, TicketSourceDTO } from './inbox.js';
+/** Daemon-minted request identity. Inbox presentation has a separate opaque ticket id. */
+export type HumanRequestIdDTO = string;
+/** The complete authored page text, inline — never a path. */
+export interface HumanRequestPageDTO {
+    dialect: 'jsx' | 'html';
+    source: string;
+}
+export interface HumanRequestDeliveryDTO {
+    placement: 'inline' | 'panel';
+    inbox: boolean;
+    reply: boolean;
+}
+/** Frozen at creation: the action name and its opaque payload. An omitted
+ *  `payload` is frozen as JSON null, so the completion document always carries it. */
+export interface HumanRequestActionDTO {
+    name: string;
+    payload?: unknown;
+}
+export interface CreateHumanRequestRequest {
+    page: HumanRequestPageDTO;
+    delivery?: HumanRequestDeliveryDTO;
+    source?: TicketSourceDTO;
+    /** The one node that receives the terminal result. Required for reply-bearing pages. */
+    requester_node_id?: string | null;
+    creator_cwd: string;
+    action?: HumanRequestActionDTO;
+}
+export type HumanRequestState = 'pending' | 'answered' | 'dismissed' | 'canceled';
+export type HumanRequestDeliveryState = 'none' | 'pending' | 'running' | 'accepted' | 'permanent_failed';
+export interface CreateHumanRequestDTO {
+    request_id: HumanRequestIdDTO;
+    /** Daemon-owned directory where the request's rendered page is projected. */
+    request_dir: string;
+    state: 'pending';
+    /** Omitted entirely when the request carries no action binding. */
+    action?: {
+        name: string;
+    };
+    delivery_state: HumanRequestDeliveryState;
+}
+export interface HumanRequestDeliveryFailureDTO {
+    kind: 'exit' | 'signal' | 'timeout' | 'spawn_error' | 'grant_refused';
+    exit_code?: number;
+    signal?: string;
+    message?: string;
+    /** A bounded tail, not full output. */
+    stderr?: string;
+}
+export interface HumanRequestDeliveryDetailDTO {
+    state: HumanRequestDeliveryState;
+    /** Attempts started. */
+    attempt: number;
+    /** Present only while pending after a retryable failure. */
+    next_attempt_at?: IsoTime;
+    accepted_at?: IsoTime;
+    permanent_failed_at?: IsoTime;
+    last_failure?: HumanRequestDeliveryFailureDTO;
+}
+export interface HumanRequestDTO {
+    request_id: HumanRequestIdDTO;
+    /** Opaque inbox identity for inbox-only routes. */
+    inbox_ticket_id: string;
+    /** Daemon-owned directory where the request's rendered page is projected. */
+    request_dir: string;
+    kind: 'page' | 'review';
+    state: HumanRequestState;
+    title: string;
+    subtitle?: string;
+    source: TicketSourceDTO;
+    emitted_at: IsoTime;
+    /** Present unless pending. */
+    settled_at?: IsoTime;
+    /** Present only when `state` is `answered`. */
+    responses?: PageResponsesDTO;
+    reason?: string;
+    actor?: string;
+    /** `action` and `delivery` are both omitted when no action is bound. */
+    action?: {
+        name: string;
+        payload: unknown;
+    };
+    delivery?: HumanRequestDeliveryDetailDTO;
+    /** Present exactly when this request is a page. */
+    page?: InboxPageDTO;
+}
+export interface ReplaceHumanRequestRequest {
+    page: HumanRequestPageDTO;
+    delivery?: HumanRequestDeliveryDTO;
+}
+export interface RespondHumanRequestRequest {
+    responses: PageResponsesDTO;
+    actor?: string;
+}
+export interface SettleHumanRequestRequest {
+    reason?: string;
+    actor?: string;
+}
+/** One product page component registered by config or an enabled plugin. */
+export interface PageComponentDTO {
+    kind: string;
+    description?: string;
+    useWhen?: string;
+    doc?: string;
+    /** A display-only product slot contributes no page response. */
+    display?: boolean;
+}
+/** `GET /v1/human/components` — the product page components the runtime's
+ *  config and enabled plugins register, merged in precedence order. */
+export interface PageComponentListDTO {
+    components: PageComponentDTO[];
+}

package/dist/api/dto/human-requests.js

@@ -0,0 +1,4 @@
+// Durable programmatic human-request DTOs — crtrd `/v1/human/requests`. The
+// envelope is snake_case; nested page-protocol objects keep their canonical
+// camelCase names, matching the inbox DTOs.
+export {};

package/dist/api/dto/human.d.ts

@@ -0,0 +1,28 @@
+/** One anchored review comment, mirroring crouter's canonical review result. */
+export interface FeedbackCommentDTO {
+    id: string;
+    line: number;
+    endLine: number;
+    quote?: string;
+    colStart?: number;
+    colEnd?: number;
+    lineText: string;
+    comment: string;
+    createdAt: string;
+}
+/** Immutable daemon-projected review approval result. */
+export interface FeedbackResultDTO {
+    file: string;
+    submitted: true;
+    approved: true;
+    comments: FeedbackCommentDTO[];
+    submittedAt: string;
+    savedAt: string;
+    reviewId: string;
+    changed: boolean;
+    baselineSha256: string;
+    approvedSha256: string;
+    companionNodeId: string;
+    commentsTotal: number;
+    commentsUnresolved: number;
+}

package/dist/api/dto/human.js

@@ -0,0 +1,4 @@
+// Shared human-review result DTOs. Page and review lifecycle contracts live in
+// their request-specific modules; bridge and duplicate ticket settlement types
+// are intentionally absent.
+export {};

package/dist/api/dto/inbox.d.ts

@@ -0,0 +1,273 @@
+import type { IsoTime } from './common.js';
+/** Opaque, stable, URL-safe ticket id: lowercase SHA-256 hex. */
+export type InboxTicketIdDTO = string;
+export interface TicketSourceDTO {
+    sessionName?: string;
+    askedBy?: string;
+    blockedSince?: IsoTime;
+    emittedAt?: IsoTime;
+    profileName?: string;
+    nodeId?: string;
+}
+export interface ReviewTicketSummaryDTO {
+    /** Request identity for direct request/review routes. */
+    request_id: string;
+    /** Daemon-owned projection directory. */
+    request_dir: string;
+    ticket_id: InboxTicketIdDTO;
+    kind: 'review';
+    title: string;
+    subtitle: string;
+    blocked_since: IsoTime;
+    source: TicketSourceDTO;
+}
+/** One question's recommended option, flat on the wire like every other summary field. */
+export interface RecommendedOptionDTO {
+    slot_id: string;
+    option_id: string;
+    label: string;
+}
+/**
+ * What one keypress on an inbox row publishes. `responses` is a complete final response
+ * map this daemon already accepts for the ticket, so a client publishes it untouched
+ * rather than assembling one from the summary.
+ */
+export interface PageFastActionDTO {
+    kind: 'answer' | 'acknowledge';
+    responses: PageResponsesDTO;
+}
+export interface PageTicketSummaryDTO {
+    /** Request identity for direct request routes. */
+    request_id: string;
+    /** Daemon-owned projection directory. */
+    request_dir: string;
+    ticket_id: InboxTicketIdDTO;
+    kind: 'page';
+    title: string;
+    subtitle?: string;
+    placement: 'inline' | 'panel';
+    dialect: 'jsx' | 'html';
+    inbox: boolean;
+    steps: number;
+    emitted_at: IsoTime;
+    source: TicketSourceDTO;
+    slot_kinds: string[];
+    /** The ticket is waiting on the person: it asks something, or an agent bridge is parked on its reply. Not a writability gate — any pending, non-passive ticket accepts a response. */
+    awaits_response: boolean;
+    /** Omitted when no question recommends an option. */
+    recommended_options?: RecommendedOptionDTO[];
+    /** Present only on a pending ticket that a row can settle without opening it. */
+    fast_action?: PageFastActionDTO;
+    state: 'pending' | 'resolved' | 'canceled' | 'passive';
+    /** Present only on resolved history entries; the stored one-line answer digest. */
+    answer_digest?: string;
+}
+export type InboxTicketSummaryDTO = PageTicketSummaryDTO | ReviewTicketSummaryDTO;
+export interface InboxListDTO {
+    tickets: InboxTicketSummaryDTO[];
+}
+export interface PageSlotDTO {
+    id?: string;
+    kind: string;
+    step: number;
+    config: Record<string, unknown>;
+    unvalidated?: true;
+    display?: true;
+}
+/** The nested protocol object is deliberately camelCase on the wire. */
+export interface PageManifestDTO {
+    schema: 'crtr.page/v2';
+    dialect: 'jsx' | 'html';
+    title: string;
+    subtitle?: string;
+    delivery: {
+        placement: 'inline' | 'panel';
+        inbox: boolean;
+        reply: boolean;
+    };
+    document: 'page.tsx' | 'page.html';
+    steps: number;
+    slots: PageSlotDTO[];
+    source?: TicketSourceDTO;
+}
+/** Answer-annotation anchors: option on UserQuestion, row on UserTable.
+ * Feedback on other page content — including the question text — is a
+ * ticket-level feedback comment, never a response anchor. */
+export interface PageCommentAnchorDTO {
+    kind: 'option' | 'row';
+    optionId?: string;
+    rowId?: string;
+}
+export interface PageCommentDTO {
+    id: string;
+    anchor: PageCommentAnchorDTO;
+    text: string;
+}
+export interface PageOptionsResponseDTO {
+    selectedOptionIds: string[];
+    comments: PageCommentDTO[];
+    freetext?: string;
+}
+export interface PageTextResponseDTO {
+    text: string;
+    edited: boolean;
+}
+export interface PageTableResponseDTO {
+    selectedRowIds: string[];
+    selectedColumnIds: string[];
+    comments: PageCommentDTO[];
+}
+export interface PageCardsResponseDTO {
+    selectedCardIds: string[];
+}
+export type SlotResponseDTO = PageOptionsResponseDTO | PageTextResponseDTO | PageTableResponseDTO | PageCardsResponseDTO | Record<string, unknown>;
+export type PageResponsesDTO = Record<string, SlotResponseDTO>;
+export interface InboxPageDTO {
+    ticket_id: InboxTicketIdDTO;
+    kind: 'page';
+    state: 'pending' | 'resolved' | 'canceled' | 'passive';
+    /** Opaque SQL-selected immutable presentation revision. */
+    revision: string;
+    page: PageManifestDTO;
+    /** JSX is compiled for the host; HTML is the authored document verbatim. */
+    document: string;
+    /** Authored JSX or HTML, distinct from the compiled JSX host document. */
+    source_document: string;
+    document_media_type: 'text/jsx' | 'text/html';
+    progress: {
+        responses: PageResponsesDTO;
+    } | null;
+    /** Canonical stored terminal result, or null while the ticket remains open. */
+    result: PageTicketResultDTO | CanceledTicketResultDTO | null;
+    /** Ticket-attached feedback comments and the companion conversation they
+     * deliver to. Comments are immutable once sent — open until the companion
+     * resolves them. */
+    feedback: PageFeedbackDTO;
+}
+export interface PageFeedbackCommentDTO {
+    id: string;
+    /** The highlighted text the note is about; for a chart, its title. */
+    quote: string;
+    /** Surrounding text that locates the quote on the page. */
+    context?: string;
+    note: string;
+    /** Open until the companion has dealt with it; resolution is terminal. */
+    status: 'open' | 'resolved';
+    created_at: IsoTime;
+    resolved_at?: IsoTime;
+}
+export interface PageFeedbackDTO {
+    /** The ticket-bound companion conversation comments deliver to; null until
+     * the first comment realizes it. */
+    companion_node_id: string | null;
+    /** How many comments remain open. Zero once feedback exists is the ticket's
+     * authoritative signal that the companion has dealt with all of it. */
+    open_count: number;
+    comments: PageFeedbackCommentDTO[];
+}
+/** `POST /v1/human/inbox/:ticket_id/feedback-comments` body. */
+export interface CreatePageFeedbackCommentRequest {
+    quote: string;
+    context?: string;
+    note: string;
+}
+export interface PageFeedbackDeliveryDTO {
+    target_node_id: string;
+    status: 'delivered' | 'failed';
+    via?: 'engine' | 'inbox';
+    woke: boolean;
+    reason?: 'capacity_frozen';
+    error?: string;
+}
+/** Create result: the new comment, the ticket's full feedback state after it,
+ * and the delivery outcome in the companion conversation. */
+export interface PageFeedbackMutationDTO {
+    comment: PageFeedbackCommentDTO;
+    feedback: PageFeedbackDTO;
+    delivery: PageFeedbackDeliveryDTO;
+}
+/** `POST .../feedback-comments/:comment_id/resolve` request. Resolution is
+ * companion-only: `node_id` names the calling node and must equal the
+ * ticket's bound companion. */
+export interface ResolvePageFeedbackCommentRequest {
+    node_id: string;
+}
+/** `POST .../feedback-comments/:comment_id/resolve` result. Resolution appends
+ * no chat turn; the companion's own conversational report covers it. */
+export interface PageFeedbackResolutionDTO {
+    comment: PageFeedbackCommentDTO;
+    feedback: PageFeedbackDTO;
+}
+export interface InboxPageHistoryDTO {
+    tickets: PageTicketSummaryDTO[];
+}
+export interface RespondInboxPageRequest {
+    responses: PageResponsesDTO;
+}
+export interface InboxPageProgressDTO {
+    responses: PageResponsesDTO;
+}
+export interface PageTicketResultDTO {
+    schema: 'crtr.page-response/v1';
+    kind: 'page';
+    responses: PageResponsesDTO;
+    summary: string;
+    completedAt: IsoTime;
+}
+export interface PageAnswerGroupDTO {
+    group: 'option' | 'card' | 'row' | 'column';
+    mode: 'single' | 'multi';
+    total: number;
+    picked: {
+        id: string;
+        label: string;
+    }[];
+}
+export interface PageAnswerCommentDTO {
+    /** Legacy stored responses may still carry the retired `whole` anchor. */
+    anchor: PageCommentAnchorDTO | {
+        kind: 'whole';
+    };
+    anchorLabel: string;
+    text: string;
+}
+export interface PageAnswerSlotDTO {
+    id: string;
+    kind: string;
+    label?: string;
+    state: 'answered' | 'unanswered';
+    blank: boolean;
+    groups: PageAnswerGroupDTO[];
+    freetext?: string;
+    text?: {
+        value: string;
+        edited: boolean;
+        singleLine?: boolean;
+    };
+    comments: PageAnswerCommentDTO[];
+    raw?: Record<string, unknown>;
+}
+/** The camelCase protocol object shipped only by GET .../response. */
+export interface PageAnswerDTO {
+    title: string;
+    subtitle?: string;
+    completedAt: IsoTime;
+    kind: 'answer' | 'acknowledgement';
+    digest: string;
+    slots: PageAnswerSlotDTO[];
+}
+export interface InboxPageResponseDTO extends PageTicketResultDTO {
+    answer: PageAnswerDTO;
+}
+/** `POST /v1/human/inbox/:ticket_id/cancel` body. */
+export interface CancelInboxTicketRequest {
+    reason?: string;
+}
+/** `POST /v1/human/inbox/:ticket_id/cancel` result. */
+export interface CanceledTicketResultDTO {
+    schema: 'humanloop.cancel/v1';
+    kind: 'canceled';
+    canceledAt: IsoTime;
+    reason?: string;
+    actor?: string;
+}

package/dist/api/dto/inbox.js

@@ -0,0 +1,4 @@
+// Humanloop inbox DTOs — crtrd `/v1/human/inbox` (crouter cloud crouter-inbox v1,
+// inbox-contract.md §A). API envelope fields use snake_case; nested page
+// protocol objects retain their canonical camelCase field names.
+export {};

package/dist/api/dto/lifecycle.d.ts

@@ -0,0 +1,88 @@
+import type { NodeIdDTO, NodeStatusDTO } from './common.js';
+/** `POST /v1/nodes/{id}/revive` body. */
+export interface ReviveRequest {
+    /** Resume the saved conversation (true) vs a fresh launch (false). */
+    resume?: boolean;
+    /** Clear the finalization latch before reviving (the `--reopen` gate). The
+     *  revive doorway accepts it only for a finalized node (`not_finalized`
+     *  otherwise); without it, a finalized node is rejected (`node_finalized`).
+     *  Message delivery has its own wider reopen behavior. */
+    reopen?: boolean;
+    /** Wake provenance: the cron whose run drove this revive (`CRTR_CRON_ID`,
+     *  set by the daemon in every cron run's environment and forwarded by the
+     *  CLI). With `resume:false` and a still-live cron row, crtrd injects the
+     *  `<crtr-wake>` block so the revived node learns a CLOCK woke it, not a
+     *  message. Prose only — an unknown id is ignored, never an error. */
+    cron_id?: string;
+}
+/** Result of a revive. `revived` is false on the idempotent double-revive no-op. */
+export interface ReviveResultDTO {
+    node_id: NodeIdDTO;
+    revived: boolean;
+    resumed: boolean;
+    status: NodeStatusDTO;
+    /** What the call did: `launched` started a broker, `already-live` found one
+     *  already running, `frozen` found no free broker slot and left the row
+     *  waiting for one. */
+    outcome: 'launched' | 'already-live' | 'frozen';
+}
+/** `POST /v1/nodes/{id}/relaunch-root` result. A null id means the target
+ * was not a relaunchable live root, or its replacement failed to launch. */
+export interface RelaunchRootResultDTO {
+    newNodeId: NodeIdDTO | null;
+}
+/** `POST /v1/nodes/revive-all` result. Node ids relaunched, any that failed to
+ *  revive with the reason, and any the broker cap turned away (the reader
+ *  reports all three). */
+export interface ReviveAllResultDTO {
+    revived: NodeIdDTO[];
+    failed: {
+        node_id: NodeIdDTO;
+        error: string;
+    }[];
+    /** Frozen for capacity, not failed: the daemon relaunches these as slots free. */
+    frozen: NodeIdDTO[];
+}
+/** `POST /v1/nodes/{id}/close` body. The cascade set is computed server-side
+ *  from edges; the flag only opts out of cascading descendants. */
+export interface CloseRequest {
+    cascade?: boolean;
+    /** PID of the shell that invoked this close. The daemon excludes this process
+     *  and its descendants from broker teardown so a node can close itself. */
+    caller_pid?: number;
+    /** Root close disposition: `true` finalizes the root to `done` (the browse `x`
+     *  "finish" semantics); default/`false` cancels it. The cascade set (computed
+     *  server-side) is torn down either way. */
+    finish?: boolean;
+}
+/** Result of a close. */
+export interface CloseResultDTO {
+    /** The closed node — the cascade root. */
+    root: NodeIdDTO;
+    /** Every node torn down (root + cascaded descendants), leaves-first. */
+    closed: NodeIdDTO[];
+    /** Descendants left alive because an out-of-subtree manager still subscribes. */
+    spared: NodeIdDTO[];
+}
+/** `POST /v1/nodes/{id}/promote` body. */
+export interface PromoteRequest {
+    /** Specialize as this kind of orchestrator; defaults to the node's current kind. */
+    kind?: string;
+    /** Also flip lifecycle→resident (interactable). */
+    resident?: boolean;
+    /** Durably change the model tier (ultra|strong). */
+    model?: string;
+}
+/** `POST /v1/nodes/{id}/yield` body. */
+export interface YieldRequest {
+    note?: string;
+    promote?: boolean;
+    /** Respecialize the kind as the node refreshes. */
+    kind?: string;
+    /** Durably raise the model tier (ultra|strong) for the fresh revive. */
+    model?: string;
+}
+/** `POST /v1/nodes/{id}/wait` body. */
+export interface WaitRequest {
+    controller: NodeIdDTO;
+}

package/dist/api/dto/lifecycle.js

@@ -0,0 +1,3 @@
+// Lifecycle action DTOs (spec §6.2). Recycle/demote take no body and return a
+// `NodeDetailDTO` (nodes.ts); revive/close/promote/yield/wait are here.
+export {};

package/dist/api/dto/limits.d.ts

@@ -0,0 +1,29 @@
+/** One app's effective caps. A null cap means the app has none of its own. */
+export interface AppLimitsDTO {
+    app: string;
+    memory_bytes: number | null;
+    disk_bytes: number | null;
+    memory_source: 'default' | 'override';
+    disk_source: 'default' | 'override';
+    /** Bytes the app's project quota counts now, or null when disk quota is off. */
+    disk_used_bytes: number | null;
+}
+export interface LimitsDTO {
+    /** False when this host cannot enforce the limit; `reason` says why. Caps are still recorded. */
+    memory_enforced: boolean;
+    memory_reason: string | null;
+    disk_enforced: boolean;
+    disk_reason: string | null;
+    apps: AppLimitsDTO[];
+}
+/** `PUT /v1/limits/apps/{app}`: omitted fields stay as they were. A value is a byte count or `unlimited`. */
+export interface SetAppLimitsRequest {
+    memory_bytes?: number | 'unlimited';
+    disk_bytes?: number | 'unlimited';
+}
+export interface AppLimitsChangeDTO {
+    app: string;
+    /** True when the launcher wrote the new caps to the running host; false when the host has no launcher. */
+    applied: boolean;
+    limits: AppLimitsDTO;
+}

package/dist/api/dto/limits.js

@@ -0,0 +1,2 @@
+// Per-app memory and disk limit DTOs (`crtr sys limits`).
+export {};