@sealant/api-contracts-next 0.0.0-next.0 → 0.39.0-next.682

package/dist/core-api/inference.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Inference on connected accounts — run short, tool-calling inference loops on the caller's OWN
+ * subscription (their connected Claude or Codex account), server-side, WITHOUT the caller ever
+ * seeing secret material.
+ *
+ * COMPLIANCE (docs/connected-accounts-design.md, load-bearing): stored subscription credentials are
+ * NEVER used for raw model-API calls. The server resolves the account reference, decrypts, and
+ * invokes the OFFICIAL runtime for the account's provider — the Claude Agent SDK for claude
+ * accounts, the Codex CLI (against a private per-invocation CODEX_HOME) for codex accounts — the
+ * exact consumption paths the vendors document for third-party apps. Requests carry account
+ * REFERENCES only; responses carry assistant turns only; token material never crosses this surface
+ * in either direction.
+ *
+ * The tool loop is CALLER-EXECUTED: the request may define JSON-schema tools; when the model calls
+ * one, the server parks the run and responds with the pending `toolCalls` turn + a `sessionId`; the
+ * caller executes the tools on ITS side and posts the results back with that `sessionId`, repeating
+ * until a `text` turn arrives. Sessions are held in memory by the serving process and expire after
+ * a few idle minutes — callers must handle `InferenceNotFoundError` on a continuation by starting
+ * the exchange over. Caller-defined tools are claude-only today: a codex exchange settles in one
+ * turn, and sending `tools` with a codex account is a 400.
+ */
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { BudgetExceededError } from "./budgets.js";
+/**
+ * Connected-account selection — the same reference shape as workspace creation: values are account
+ * ids (`cacc_…`) or per-provider account names; explicit entries win over the profile's bindings.
+ * Selecting both `claude` and `codex` in one exchange is ambiguous (400). A profileId-only
+ * selection prefers the profile's claude binding and falls back to its codex binding.
+ */
+export declare const inferenceCredentialsSchema: Schema.Struct<{
+    readonly profileId: Schema.optional<Schema.String>;
+    readonly claude: Schema.optional<Schema.String>;
+    readonly codex: Schema.optional<Schema.String>;
+}>;
+export type InferenceCredentials = typeof inferenceCredentialsSchema.Type;
+/** A caller-defined tool. `inputSchema` is a JSON Schema object, passed to the model verbatim. */
+export declare const inferenceToolSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly inputSchema: Schema.Unknown;
+}>;
+export type InferenceTool = typeof inferenceToolSchema.Type;
+/** The caller's result for one parked tool call, keyed by the server-minted `toolCallId`. */
+export declare const inferenceToolResultSchema: Schema.Struct<{
+    readonly toolCallId: Schema.String;
+    readonly content: Schema.String;
+    readonly isError: Schema.optional<Schema.Boolean>;
+}>;
+export type InferenceToolResult = typeof inferenceToolResultSchema.Type;
+/**
+ * One respond call, in one of two shapes:
+ *
+ * - NEW exchange: `credentials` + `prompt` (plus optional `system`/`model`/`tools`/
+ *   `responseFormat`/`maxTurns`). `sessionId`/`toolResults` must be absent.
+ * - CONTINUATION: `sessionId` + `toolResults` for the previous turn's tool calls. The session was
+ *   authenticated when it started; credential fields must be absent.
+ */
+export declare const inferenceRespondRequestSchema: Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+    readonly credentials: Schema.optional<Schema.Struct<{
+        readonly profileId: Schema.optional<Schema.String>;
+        readonly claude: Schema.optional<Schema.String>;
+        readonly codex: Schema.optional<Schema.String>;
+    }>>;
+    readonly prompt: Schema.optional<Schema.String>;
+    readonly system: Schema.optional<Schema.String>;
+    /** Model override passed to the official runtime verbatim (defaults to the runtime's default). */
+    readonly model: Schema.optional<Schema.String>;
+    /** Upper bound on agentic turns within one exchange (default 16). Claude-only; ignored by codex. */
+    readonly maxTurns: Schema.optional<Schema.Number>;
+    readonly tools: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly inputSchema: Schema.Unknown;
+    }>>>;
+    /**
+     * Structured-output option: instructs the model to answer as JSON (conforming to `schema` when
+     * given) and parses the final text; the parsed value arrives as the text turn's `json` field.
+     * Best-effort — when the text does not parse, `json` is absent and `text` still carries the raw
+     * answer.
+     */
+    readonly responseFormat: Schema.optional<Schema.Struct<{
+        readonly type: Schema.Literal<"json">;
+        readonly schema: Schema.optional<Schema.Unknown>;
+    }>>;
+    readonly sessionId: Schema.optional<Schema.String>;
+    readonly toolResults: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly toolCallId: Schema.String;
+        readonly content: Schema.String;
+        readonly isError: Schema.optional<Schema.Boolean>;
+    }>>>;
+}>;
+export type InferenceRespondRequest = typeof inferenceRespondRequestSchema.Type;
+/** A tool call the model made; the caller executes it and posts the result back. */
+export declare const inferenceToolCallSchema: Schema.Struct<{
+    readonly toolCallId: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+}>;
+export type InferenceToolCall = typeof inferenceToolCallSchema.Type;
+/** The assistant turn: either the final text (with optional parsed `json`) or pending tool calls. */
+export declare const inferenceTurnSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly json: Schema.optional<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"toolCalls">;
+    readonly calls: Schema.$Array<Schema.Struct<{
+        readonly toolCallId: Schema.String;
+        readonly name: Schema.String;
+        readonly input: Schema.Unknown;
+    }>>;
+}>]>;
+export type InferenceTurn = typeof inferenceTurnSchema.Type;
+export declare const inferenceUsageSchema: Schema.Struct<{
+    readonly inputTokens: Schema.Number;
+    readonly outputTokens: Schema.Number;
+}>;
+export type InferenceUsage = typeof inferenceUsageSchema.Type;
+export declare const inferenceRespondResponseSchema: Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly turn: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly json: Schema.optional<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"toolCalls">;
+        readonly calls: Schema.$Array<Schema.Struct<{
+            readonly toolCallId: Schema.String;
+            readonly name: Schema.String;
+            readonly input: Schema.Unknown;
+        }>>;
+    }>]>;
+    /** Usage for the exchange so far; present on the final (text) turn. */
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+    }>>;
+}>;
+export type InferenceRespondResponse = typeof inferenceRespondResponseSchema.Type;
+declare const InferenceBadRequestError_base: Schema.Class<InferenceBadRequestError, Schema.TaggedStruct<"InferenceBadRequestError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InferenceBadRequestError extends InferenceBadRequestError_base {
+}
+declare const InferenceNotFoundError_base: Schema.Class<InferenceNotFoundError, Schema.TaggedStruct<"InferenceNotFoundError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Unknown account/profile (uniform for foreign owners) or an expired/unknown inference session. */
+export declare class InferenceNotFoundError extends InferenceNotFoundError_base {
+}
+declare const InferenceConflictError_base: Schema.Class<InferenceConflictError, Schema.TaggedStruct<"InferenceConflictError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The selected account exists but is not usable (status "invalid") — reconnect it. */
+export declare class InferenceConflictError extends InferenceConflictError_base {
+}
+declare const InferenceUnavailableError_base: Schema.Class<InferenceUnavailableError, Schema.TaggedStruct<"InferenceUnavailableError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InferenceUnavailableError extends InferenceUnavailableError_base {
+}
+declare const InferenceInternalServerError_base: Schema.Class<InferenceInternalServerError, Schema.TaggedStruct<"InferenceInternalServerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InferenceInternalServerError extends InferenceInternalServerError_base {
+}
+export declare const InferenceGroup: HttpApiGroup.HttpApiGroup<"inference", HttpApiEndpoint.HttpApiEndpoint<"respond", "POST", "/respond", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+    readonly credentials: Schema.optional<Schema.Struct<{
+        readonly profileId: Schema.optional<Schema.String>;
+        readonly claude: Schema.optional<Schema.String>;
+        readonly codex: Schema.optional<Schema.String>;
+    }>>;
+    readonly prompt: Schema.optional<Schema.String>;
+    readonly system: Schema.optional<Schema.String>;
+    /** Model override passed to the official runtime verbatim (defaults to the runtime's default). */
+    readonly model: Schema.optional<Schema.String>;
+    /** Upper bound on agentic turns within one exchange (default 16). Claude-only; ignored by codex. */
+    readonly maxTurns: Schema.optional<Schema.Number>;
+    readonly tools: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly inputSchema: Schema.Unknown;
+    }>>>;
+    /**
+     * Structured-output option: instructs the model to answer as JSON (conforming to `schema` when
+     * given) and parses the final text; the parsed value arrives as the text turn's `json` field.
+     * Best-effort — when the text does not parse, `json` is absent and `text` still carries the raw
+     * answer.
+     */
+    readonly responseFormat: Schema.optional<Schema.Struct<{
+        readonly type: Schema.Literal<"json">;
+        readonly schema: Schema.optional<Schema.Unknown>;
+    }>>;
+    readonly sessionId: Schema.optional<Schema.String>;
+    readonly toolResults: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly toolCallId: Schema.String;
+        readonly content: Schema.String;
+        readonly isError: Schema.optional<Schema.Boolean>;
+    }>>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly sessionId: Schema.String;
+    readonly turn: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly json: Schema.optional<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"toolCalls">;
+        readonly calls: Schema.$Array<Schema.Struct<{
+            readonly toolCallId: Schema.String;
+            readonly name: Schema.String;
+            readonly input: Schema.Unknown;
+        }>>;
+    }>]>;
+    /** Usage for the exchange so far; present on the final (text) turn. */
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+    }>>;
+}>>, HttpApiEndpoint.Json<typeof BudgetExceededError | typeof InferenceBadRequestError | typeof InferenceNotFoundError | typeof InferenceConflictError | typeof InferenceUnavailableError | typeof InferenceInternalServerError>, never, never>, false>;
+export {};

package/dist/core-api/inference.js

@@ -0,0 +1,139 @@
+/**
+ * Inference on connected accounts — run short, tool-calling inference loops on the caller's OWN
+ * subscription (their connected Claude or Codex account), server-side, WITHOUT the caller ever
+ * seeing secret material.
+ *
+ * COMPLIANCE (docs/connected-accounts-design.md, load-bearing): stored subscription credentials are
+ * NEVER used for raw model-API calls. The server resolves the account reference, decrypts, and
+ * invokes the OFFICIAL runtime for the account's provider — the Claude Agent SDK for claude
+ * accounts, the Codex CLI (against a private per-invocation CODEX_HOME) for codex accounts — the
+ * exact consumption paths the vendors document for third-party apps. Requests carry account
+ * REFERENCES only; responses carry assistant turns only; token material never crosses this surface
+ * in either direction.
+ *
+ * The tool loop is CALLER-EXECUTED: the request may define JSON-schema tools; when the model calls
+ * one, the server parks the run and responds with the pending `toolCalls` turn + a `sessionId`; the
+ * caller executes the tools on ITS side and posts the results back with that `sessionId`, repeating
+ * until a `text` turn arrives. Sessions are held in memory by the serving process and expire after
+ * a few idle minutes — callers must handle `InferenceNotFoundError` on a continuation by starting
+ * the exchange over. Caller-defined tools are claude-only today: a codex exchange settles in one
+ * turn, and sending `tools` with a codex account is a 400.
+ */
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { BudgetExceededError } from "./budgets.js";
+const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
+/**
+ * Connected-account selection — the same reference shape as workspace creation: values are account
+ * ids (`cacc_…`) or per-provider account names; explicit entries win over the profile's bindings.
+ * Selecting both `claude` and `codex` in one exchange is ambiguous (400). A profileId-only
+ * selection prefers the profile's claude binding and falls back to its codex binding.
+ */
+export const inferenceCredentialsSchema = Schema.Struct({
+    profileId: Schema.optional(NonEmptyString),
+    claude: Schema.optional(NonEmptyString),
+    codex: Schema.optional(NonEmptyString),
+});
+/** A caller-defined tool. `inputSchema` is a JSON Schema object, passed to the model verbatim. */
+export const inferenceToolSchema = Schema.Struct({
+    name: NonEmptyString,
+    description: Schema.optional(Schema.String),
+    inputSchema: Schema.Unknown,
+});
+/** The caller's result for one parked tool call, keyed by the server-minted `toolCallId`. */
+export const inferenceToolResultSchema = Schema.Struct({
+    toolCallId: NonEmptyString,
+    content: Schema.String,
+    isError: Schema.optional(Schema.Boolean),
+});
+/**
+ * One respond call, in one of two shapes:
+ *
+ * - NEW exchange: `credentials` + `prompt` (plus optional `system`/`model`/`tools`/
+ *   `responseFormat`/`maxTurns`). `sessionId`/`toolResults` must be absent.
+ * - CONTINUATION: `sessionId` + `toolResults` for the previous turn's tool calls. The session was
+ *   authenticated when it started; credential fields must be absent.
+ */
+export const inferenceRespondRequestSchema = Schema.Struct({
+    ownerUserId: NonEmptyString,
+    credentials: Schema.optional(inferenceCredentialsSchema),
+    prompt: Schema.optional(Schema.String.check(Schema.isNonEmpty())),
+    system: Schema.optional(Schema.String),
+    /** Model override passed to the official runtime verbatim (defaults to the runtime's default). */
+    model: Schema.optional(NonEmptyString),
+    /** Upper bound on agentic turns within one exchange (default 16). Claude-only; ignored by codex. */
+    maxTurns: Schema.optional(Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 64 }))),
+    tools: Schema.optional(Schema.Array(inferenceToolSchema).check(Schema.isMaxLength(32))),
+    /**
+     * Structured-output option: instructs the model to answer as JSON (conforming to `schema` when
+     * given) and parses the final text; the parsed value arrives as the text turn's `json` field.
+     * Best-effort — when the text does not parse, `json` is absent and `text` still carries the raw
+     * answer.
+     */
+    responseFormat: Schema.optional(Schema.Struct({
+        type: Schema.Literal("json"),
+        schema: Schema.optional(Schema.Unknown),
+    })),
+    sessionId: Schema.optional(NonEmptyString),
+    toolResults: Schema.optional(Schema.Array(inferenceToolResultSchema).check(Schema.isNonEmpty())),
+});
+/** A tool call the model made; the caller executes it and posts the result back. */
+export const inferenceToolCallSchema = Schema.Struct({
+    toolCallId: NonEmptyString,
+    name: NonEmptyString,
+    input: Schema.Unknown,
+});
+/** The assistant turn: either the final text (with optional parsed `json`) or pending tool calls. */
+export const inferenceTurnSchema = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("text"),
+        text: Schema.String,
+        json: Schema.optional(Schema.Unknown),
+    }),
+    Schema.Struct({
+        type: Schema.Literal("toolCalls"),
+        calls: Schema.Array(inferenceToolCallSchema),
+    }),
+]);
+export const inferenceUsageSchema = Schema.Struct({
+    inputTokens: Schema.Number,
+    outputTokens: Schema.Number,
+});
+export const inferenceRespondResponseSchema = Schema.Struct({
+    sessionId: NonEmptyString,
+    turn: inferenceTurnSchema,
+    /** Usage for the exchange so far; present on the final (text) turn. */
+    usage: Schema.optional(inferenceUsageSchema),
+});
+// ---------------------------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------------------------
+export class InferenceBadRequestError extends Schema.TaggedErrorClass()("InferenceBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
+}
+/** Unknown account/profile (uniform for foreign owners) or an expired/unknown inference session. */
+export class InferenceNotFoundError extends Schema.TaggedErrorClass()("InferenceNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
+}
+/** The selected account exists but is not usable (status "invalid") — reconnect it. */
+export class InferenceConflictError extends Schema.TaggedErrorClass()("InferenceConflictError", { message: Schema.String }, { httpApiStatus: 409 }) {
+}
+export class InferenceUnavailableError extends Schema.TaggedErrorClass()("InferenceUnavailableError", { message: Schema.String }, { httpApiStatus: 503 }) {
+}
+export class InferenceInternalServerError extends Schema.TaggedErrorClass()("InferenceInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
+}
+// ---------------------------------------------------------------------------------------------
+// Group
+// ---------------------------------------------------------------------------------------------
+export const InferenceGroup = HttpApiGroup.make("inference")
+    .add(HttpApiEndpoint.post("respond", "/respond", {
+    payload: inferenceRespondRequestSchema,
+    success: inferenceRespondResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [
+        BudgetExceededError,
+        InferenceBadRequestError,
+        InferenceNotFoundError,
+        InferenceConflictError,
+        InferenceUnavailableError,
+        InferenceInternalServerError,
+    ],
+}))
+    .annotate(OpenApi.Description, "Inference on connected accounts, via the official agent SDKs — never raw model-API calls.");

package/dist/core-api/oci-names.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Canonical OCI names (distribution-spec "Pulling manifests"). A repository or reference that does
+ * not match is refused, never repaired: these values become URL path segments and `docker`
+ * arguments, and anything the grammar does not admit (`..`, `%2e`, `?`, `#`, a scheme, a
+ * backslash, whitespace, an empty segment) is a way to address something else.
+ */
+export declare const isOciRepository: (value: string) => boolean;
+export declare const isOciTag: (value: string) => boolean;
+export declare const isOciDigest: (value: string) => boolean;
+/** A manifest reference is a tag or a digest. */
+export declare const isOciReference: (value: string) => boolean;
+/**
+ * One path component of a repository name, made from arbitrary text (a Git repository's name, an
+ * OS family). This is for names Sealant GENERATES; a name a caller supplies is refused, not
+ * rewritten. A lone `.` or `_` between alphanumerics survives, every other run of characters the
+ * grammar does not admit becomes one `-`, and the edges are trimmed again after the cut so a
+ * separator can never end the component.
+ */
+export declare const toOciRepositoryComponent: (value: string, fallback: string, maxLength?: number) => string;
+export declare const OCI_REPOSITORY_MESSAGE = "must be an OCI repository name: lowercase path components of [a-z0-9] joined by '.', '_', '__' or '-', separated by '/'";
+export declare const OCI_REFERENCE_MESSAGE = "must be an OCI tag ([A-Za-z0-9_][A-Za-z0-9._-]{0,127}) or a digest (algorithm:encoded)";

package/dist/core-api/oci-names.js

@@ -0,0 +1,44 @@
+/**
+ * Canonical OCI names (distribution-spec "Pulling manifests"). A repository or reference that does
+ * not match is refused, never repaired: these values become URL path segments and `docker`
+ * arguments, and anything the grammar does not admit (`..`, `%2e`, `?`, `#`, a scheme, a
+ * backslash, whitespace, an empty segment) is a way to address something else.
+ */
+/** `<name>` : lowercase path components separated by `/`, each `[a-z0-9]+` joined by `.`, `_`, `__` or `-`s. */
+const REPOSITORY_COMPONENT = "[a-z0-9]+(?:(?:\\.|_|__|-+)[a-z0-9]+)*";
+const REPOSITORY = new RegExp(`^${REPOSITORY_COMPONENT}(?:/${REPOSITORY_COMPONENT})*$`);
+const REPOSITORY_MAX_LENGTH = 255;
+/** `<tag>`: at most 128 of `[A-Za-z0-9_.-]`, not starting with `.` or `-`. */
+const TAG = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$/;
+/** `<digest>`: `algorithm:encoded`; the registered algorithms are checked for their exact length. */
+const DIGEST = /^[a-z0-9]+(?:[+._-][a-z0-9]+)*:[A-Za-z0-9=_-]+$/;
+const DIGEST_MAX_LENGTH = 512;
+const REGISTERED_DIGEST_LENGTHS = { sha256: 64, sha512: 128 };
+export const isOciRepository = (value) => value.length <= REPOSITORY_MAX_LENGTH && REPOSITORY.test(value);
+export const isOciTag = (value) => TAG.test(value);
+export const isOciDigest = (value) => {
+    if (value.length > DIGEST_MAX_LENGTH || !DIGEST.test(value))
+        return false;
+    const separator = value.indexOf(":");
+    const expected = REGISTERED_DIGEST_LENGTHS[value.slice(0, separator)];
+    if (expected === undefined)
+        return true;
+    const encoded = value.slice(separator + 1);
+    return encoded.length === expected && /^[a-f0-9]+$/.test(encoded);
+};
+/** A manifest reference is a tag or a digest. */
+export const isOciReference = (value) => isOciDigest(value) || isOciTag(value);
+const trimEdges = (text) => text.replace(/^[._-]+|[._-]+$/g, "");
+/**
+ * One path component of a repository name, made from arbitrary text (a Git repository's name, an
+ * OS family). This is for names Sealant GENERATES; a name a caller supplies is refused, not
+ * rewritten. A lone `.` or `_` between alphanumerics survives, every other run of characters the
+ * grammar does not admit becomes one `-`, and the edges are trimmed again after the cut so a
+ * separator can never end the component.
+ */
+export const toOciRepositoryComponent = (value, fallback, maxLength = 48) => {
+    const component = trimEdges(trimEdges(value.toLowerCase().replace(/[^a-z0-9]+/g, (run) => (run === "." || run === "_" ? run : "-"))).slice(0, maxLength));
+    return component.length > 0 ? component : fallback;
+};
+export const OCI_REPOSITORY_MESSAGE = "must be an OCI repository name: lowercase path components of [a-z0-9] joined by '.', '_', '__' or '-', separated by '/'";
+export const OCI_REFERENCE_MESSAGE = "must be an OCI tag ([A-Za-z0-9_][A-Za-z0-9._-]{0,127}) or a digest (algorithm:encoded)";

package/dist/core-api/packages.d.ts

@@ -0,0 +1,179 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const packageTargetOsSchema: Schema.Literals<readonly ["arch", "fedora", "nix", "ubuntu"]>;
+export type PackageTargetOs = typeof packageTargetOsSchema.Type;
+export declare const packageResolutionStatusSchema: Schema.Literals<readonly ["resolved", "ambiguous", "unsupported", "not-found", "invalid"]>;
+export declare const packageResolutionSourceSchema: Schema.Literals<readonly ["cache", "repology", "override"]>;
+export declare const packageOsSupportSchema: Schema.Struct<{
+    readonly supported: Schema.Boolean;
+    readonly repo: Schema.optional<Schema.String>;
+    readonly packageName: Schema.optional<Schema.String>;
+    readonly projectName: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
+    readonly status: Schema.optional<Schema.String>;
+}>;
+export declare const packageResolutionAlternativeSchema: Schema.Struct<{
+    readonly projectName: Schema.String;
+}>;
+export declare const packageResolutionSchema: Schema.Struct<{
+    readonly requested: Schema.String;
+    readonly normalized: Schema.String;
+    readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "unsupported", "not-found", "invalid"]>;
+    readonly source: Schema.Literals<readonly ["cache", "repology", "override"]>;
+    readonly canonicalId: Schema.optional<Schema.String>;
+    readonly selectedProject: Schema.optional<Schema.String>;
+    readonly osSupport: Schema.Struct<{
+        readonly arch: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly fedora: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly nix: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly ubuntu: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly alternatives: Schema.$Array<Schema.Struct<{
+        readonly projectName: Schema.String;
+    }>>;
+    readonly fetchedAt: Schema.String;
+    readonly expiresAt: Schema.String;
+}>;
+export type PackageResolution = typeof packageResolutionSchema.Type;
+export declare const resolvePackageQuerySchema: Schema.Struct<{
+    readonly query: Schema.String;
+    readonly targetOs: Schema.optional<Schema.Literals<readonly ["arch", "fedora", "nix", "ubuntu"]>>;
+}>;
+export type ResolvePackageQuery = typeof resolvePackageQuerySchema.Type;
+export declare const resolvePackageResponseSchema: Schema.Struct<{
+    readonly requested: Schema.String;
+    readonly normalized: Schema.String;
+    readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "unsupported", "not-found", "invalid"]>;
+    readonly source: Schema.Literals<readonly ["cache", "repology", "override"]>;
+    readonly canonicalId: Schema.optional<Schema.String>;
+    readonly selectedProject: Schema.optional<Schema.String>;
+    readonly osSupport: Schema.Struct<{
+        readonly arch: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly fedora: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly nix: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly ubuntu: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly alternatives: Schema.$Array<Schema.Struct<{
+        readonly projectName: Schema.String;
+    }>>;
+    readonly fetchedAt: Schema.String;
+    readonly expiresAt: Schema.String;
+}>;
+export type ResolvePackageResponse = typeof resolvePackageResponseSchema.Type;
+declare const PackagesBadGatewayError_base: Schema.Class<PackagesBadGatewayError, Schema.TaggedStruct<"PackagesBadGatewayError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PackagesBadGatewayError extends PackagesBadGatewayError_base {
+}
+declare const PackagesInternalServerError_base: Schema.Class<PackagesInternalServerError, Schema.TaggedStruct<"PackagesInternalServerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PackagesInternalServerError extends PackagesInternalServerError_base {
+}
+export declare const PackagesGroup: HttpApiGroup.HttpApiGroup<"packages", HttpApiEndpoint.HttpApiEndpoint<"resolvePackage", "GET", "/resolve", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly targetOs: Schema.optional<Schema.Literals<readonly ["arch", "fedora", "nix", "ubuntu"]>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly requested: Schema.String;
+    readonly normalized: Schema.String;
+    readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "unsupported", "not-found", "invalid"]>;
+    readonly source: Schema.Literals<readonly ["cache", "repology", "override"]>;
+    readonly canonicalId: Schema.optional<Schema.String>;
+    readonly selectedProject: Schema.optional<Schema.String>;
+    readonly osSupport: Schema.Struct<{
+        readonly arch: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly fedora: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly nix: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+        readonly ubuntu: Schema.Struct<{
+            readonly supported: Schema.Boolean;
+            readonly repo: Schema.optional<Schema.String>;
+            readonly packageName: Schema.optional<Schema.String>;
+            readonly projectName: Schema.optional<Schema.String>;
+            readonly version: Schema.optional<Schema.String>;
+            readonly status: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly alternatives: Schema.$Array<Schema.Struct<{
+        readonly projectName: Schema.String;
+    }>>;
+    readonly fetchedAt: Schema.String;
+    readonly expiresAt: Schema.String;
+}>>, HttpApiEndpoint.Json<typeof PackagesBadGatewayError | typeof PackagesInternalServerError>, never, never>, false>;
+export {};