@sylphx/contract 0.2.0

package/dist/endpoints/project-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-manifest.d.ts","sourceRoot":"","sources":["../../src/endpoints/project-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AA2B/B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB3B,CAAA"}

package/dist/endpoints/project-manifest.js

@@ -0,0 +1,59 @@
+/**
+ * Project Manifest endpoints — `sylphx.toml` persistence.
+ *
+ * Mount point: `/projects/:id/manifest` (Management plane). Paths recorded
+ * relative to `/projects`. Every field is typed from the
+ * `SylphxManifest` schema in `schemas/project-manifest.ts` — the SSOT per
+ * ADR-084 Rule 1.
+ *
+ * GET returns the *latest* version (or `null` when none has been pushed
+ * yet — the caller then synthesises one from live state). PUT creates a
+ * brand-new row with an incremented version number so history / rollback
+ * / audit come for free.
+ */
+import { Schema } from 'effect';
+import { defineEndpoint } from '../endpoint.js';
+import { SylphxManifest } from '../schemas/project-manifest.js';
+const IdPath = Schema.Struct({ id: Schema.String });
+/**
+ * Successful GET response — `manifest` is null when no manifest has ever
+ * been pushed. Keeping `version` + `updatedAt` alongside lets the CLI
+ * render drift headers even when the file on disk is brand new.
+ */
+const ManifestGetResponse = Schema.Struct({
+    manifest: Schema.NullOr(SylphxManifest),
+    version: Schema.NullOr(Schema.Number),
+    updatedAt: Schema.NullOr(Schema.String),
+});
+/**
+ * Successful PUT response — returns the new version number + timestamp.
+ * The manifest body itself is not echoed (clients already have it; saves
+ * bandwidth on deploy-push paths).
+ */
+const ManifestPutResponse = Schema.Struct({
+    version: Schema.Number,
+    updatedAt: Schema.String,
+});
+export const projectManifestEndpoints = {
+    get: defineEndpoint({
+        method: 'GET',
+        path: '/projects/:id/manifest',
+        params: IdPath,
+        response: ManifestGetResponse,
+        summary: 'Fetch the latest persisted sylphx.toml manifest for a project',
+        description: 'Returns the most recently pushed manifest. `manifest` is null when the project has not yet had `sylphx config push` invoked — callers should synthesise a starter from live state.',
+        tags: ['projects', 'manifest'],
+        plane: 'management',
+    }),
+    put: defineEndpoint({
+        method: 'PUT',
+        path: '/projects/:id/manifest',
+        params: IdPath,
+        body: SylphxManifest,
+        response: ManifestPutResponse,
+        summary: 'Persist a new sylphx.toml manifest version for a project',
+        description: 'Inserts a new row in `project_manifests` with an incremented version. Never mutates prior versions — history + rollback come for free.',
+        tags: ['projects', 'manifest'],
+        plane: 'management',
+    }),
+};

package/dist/endpoints/projects.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Projects endpoints — CRUD surface for the top-level container entity.
+ *
+ * Mount point: `/projects` (Management plane). Paths here are recorded
+ * relative to that prefix. The list `{ object: 'list', data: Project[] }`
+ * envelope mirrors Stripe-style pagination envelopes — widened to match the
+ * production API handler (ADR-084 Wave 2b).
+ */
+import { Schema } from 'effect';
+export declare const projectsEndpoints: {
+    readonly list: import("../endpoint.js").Endpoint<"GET", "/projects", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        object: Schema.Literal<["list"]>;
+        data: Schema.Array$<Schema.Struct<{
+            id: Schema.brand<Schema.filter<typeof Schema.String>, "ProjectId">;
+            slug: typeof Schema.String;
+            name: typeof Schema.String;
+            ref: Schema.optional<typeof Schema.String>;
+            description: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            orgId: Schema.optional<Schema.brand<Schema.filter<typeof Schema.String>, "OrgId">>;
+            isActive: Schema.optional<typeof Schema.Boolean>;
+            sdkUrl: Schema.optional<typeof Schema.String>;
+            infraStatus: Schema.optional<typeof Schema.String>;
+            domains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            webhookUrl: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            webhookEvents: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            enabledOAuthProviders: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            buildMachineType: Schema.optional<typeof Schema.String>;
+            settings: Schema.optional<Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+            createdAt: Schema.optional<typeof Schema.String>;
+            updatedAt: Schema.optional<typeof Schema.String>;
+            environments: Schema.optional<Schema.Array$<Schema.Struct<{
+                id: Schema.brand<Schema.filter<typeof Schema.String>, "EnvironmentId">;
+                slug: Schema.optional<typeof Schema.String>;
+                name: typeof Schema.String;
+                envType: Schema.optional<typeof Schema.String>;
+                isActive: Schema.optional<typeof Schema.Boolean>;
+                publicKey: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                secretKeyPrefix: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                deployAppId: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                namespace: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                githubRepo: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                githubBranch: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                customDomains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+                createdAt: Schema.optional<typeof Schema.String>;
+                updatedAt: Schema.optional<typeof Schema.String>;
+            }>>>;
+        }>>;
+    }>>;
+    readonly create: import("../endpoint.js").Endpoint<"POST", "/projects", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        name: typeof Schema.String;
+        slug: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+        gitRepository: Schema.optional<typeof Schema.String>;
+        gitBranch: Schema.optional<typeof Schema.String>;
+        buildPack: Schema.optional<typeof Schema.String>;
+        dockerImage: Schema.optional<typeof Schema.String>;
+        port: Schema.optional<typeof Schema.Number>;
+        domain: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        app: Schema.Struct<{
+            id: Schema.brand<Schema.filter<typeof Schema.String>, "ProjectId">;
+            slug: typeof Schema.String;
+            name: typeof Schema.String;
+            ref: Schema.optional<typeof Schema.String>;
+            description: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            orgId: Schema.optional<Schema.brand<Schema.filter<typeof Schema.String>, "OrgId">>;
+            isActive: Schema.optional<typeof Schema.Boolean>;
+            sdkUrl: Schema.optional<typeof Schema.String>;
+            infraStatus: Schema.optional<typeof Schema.String>;
+            domains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            webhookUrl: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            webhookEvents: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            enabledOAuthProviders: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            buildMachineType: Schema.optional<typeof Schema.String>;
+            settings: Schema.optional<Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+            createdAt: Schema.optional<typeof Schema.String>;
+            updatedAt: Schema.optional<typeof Schema.String>;
+            environments: Schema.optional<Schema.Array$<Schema.Struct<{
+                id: Schema.brand<Schema.filter<typeof Schema.String>, "EnvironmentId">;
+                slug: Schema.optional<typeof Schema.String>;
+                name: typeof Schema.String;
+                envType: Schema.optional<typeof Schema.String>;
+                isActive: Schema.optional<typeof Schema.Boolean>;
+                publicKey: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                secretKeyPrefix: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                deployAppId: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                namespace: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                githubRepo: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                githubBranch: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+                customDomains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+                createdAt: Schema.optional<typeof Schema.String>;
+                updatedAt: Schema.optional<typeof Schema.String>;
+            }>>>;
+        }>;
+    }>>;
+    readonly get: import("../endpoint.js").Endpoint<"GET", "/projects/:id", Schema.Struct<{
+        id: typeof Schema.String;
+    }>, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        id: Schema.brand<Schema.filter<typeof Schema.String>, "ProjectId">;
+        slug: typeof Schema.String;
+        name: typeof Schema.String;
+        ref: Schema.optional<typeof Schema.String>;
+        description: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        orgId: Schema.optional<Schema.brand<Schema.filter<typeof Schema.String>, "OrgId">>;
+        isActive: Schema.optional<typeof Schema.Boolean>;
+        sdkUrl: Schema.optional<typeof Schema.String>;
+        infraStatus: Schema.optional<typeof Schema.String>;
+        domains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+        webhookUrl: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        webhookEvents: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+        enabledOAuthProviders: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+        buildMachineType: Schema.optional<typeof Schema.String>;
+        settings: Schema.optional<Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+        createdAt: Schema.optional<typeof Schema.String>;
+        updatedAt: Schema.optional<typeof Schema.String>;
+        environments: Schema.optional<Schema.Array$<Schema.Struct<{
+            id: Schema.brand<Schema.filter<typeof Schema.String>, "EnvironmentId">;
+            slug: Schema.optional<typeof Schema.String>;
+            name: typeof Schema.String;
+            envType: Schema.optional<typeof Schema.String>;
+            isActive: Schema.optional<typeof Schema.Boolean>;
+            publicKey: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            secretKeyPrefix: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            deployAppId: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            namespace: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            githubRepo: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            githubBranch: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            customDomains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            createdAt: Schema.optional<typeof Schema.String>;
+            updatedAt: Schema.optional<typeof Schema.String>;
+        }>>>;
+    }>>;
+    readonly update: import("../endpoint.js").Endpoint<"PATCH", "/projects/:id", Schema.Struct<{
+        id: typeof Schema.String;
+    }>, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        name: Schema.optional<typeof Schema.String>;
+        description: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        domains: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        webhookUrl: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        webhookEvents: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        enabledOAuthProviders: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        buildMachineType: Schema.optional<Schema.Literal<["standard", "large", "xlarge"]>>;
+    }>, Schema.Struct<{
+        id: Schema.brand<Schema.filter<typeof Schema.String>, "ProjectId">;
+        slug: typeof Schema.String;
+        name: typeof Schema.String;
+        ref: Schema.optional<typeof Schema.String>;
+        description: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        orgId: Schema.optional<Schema.brand<Schema.filter<typeof Schema.String>, "OrgId">>;
+        isActive: Schema.optional<typeof Schema.Boolean>;
+        sdkUrl: Schema.optional<typeof Schema.String>;
+        infraStatus: Schema.optional<typeof Schema.String>;
+        domains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+        webhookUrl: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        webhookEvents: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+        enabledOAuthProviders: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+        buildMachineType: Schema.optional<typeof Schema.String>;
+        settings: Schema.optional<Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+        createdAt: Schema.optional<typeof Schema.String>;
+        updatedAt: Schema.optional<typeof Schema.String>;
+        environments: Schema.optional<Schema.Array$<Schema.Struct<{
+            id: Schema.brand<Schema.filter<typeof Schema.String>, "EnvironmentId">;
+            slug: Schema.optional<typeof Schema.String>;
+            name: typeof Schema.String;
+            envType: Schema.optional<typeof Schema.String>;
+            isActive: Schema.optional<typeof Schema.Boolean>;
+            publicKey: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            secretKeyPrefix: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            deployAppId: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            namespace: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            githubRepo: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            githubBranch: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            customDomains: Schema.optional<Schema.NullOr<Schema.Array$<typeof Schema.String>>>;
+            createdAt: Schema.optional<typeof Schema.String>;
+            updatedAt: Schema.optional<typeof Schema.String>;
+        }>>>;
+    }>>;
+    readonly delete: import("../endpoint.js").Endpoint<"DELETE", "/projects/:id", Schema.Struct<{
+        id: typeof Schema.String;
+    }>, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        deleted: typeof Schema.Boolean;
+        projectId: Schema.brand<Schema.filter<typeof Schema.String>, "ProjectId">;
+        queued: typeof Schema.Boolean;
+        warnings: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>>;
+};
+//# sourceMappingURL=projects.d.ts.map

package/dist/endpoints/projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../src/endpoints/projects.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAiB/B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCpB,CAAA"}

package/dist/endpoints/projects.js

@@ -0,0 +1,58 @@
+/**
+ * Projects endpoints — CRUD surface for the top-level container entity.
+ *
+ * Mount point: `/projects` (Management plane). Paths here are recorded
+ * relative to that prefix. The list `{ object: 'list', data: Project[] }`
+ * envelope mirrors Stripe-style pagination envelopes — widened to match the
+ * production API handler (ADR-084 Wave 2b).
+ */
+import { Schema } from 'effect';
+import { defineEndpoint } from '../endpoint.js';
+import { CreateProjectInput, CreateProjectResult, DeleteProjectResult, Project, UpdateProjectInput, } from '../schemas/project.js';
+const IdPath = Schema.Struct({ id: Schema.String });
+const ListResponse = Schema.Struct({
+    object: Schema.Literal('list'),
+    data: Schema.Array(Project),
+});
+export const projectsEndpoints = {
+    list: defineEndpoint({
+        method: 'GET',
+        path: '/projects',
+        response: ListResponse,
+        summary: 'List projects visible to the caller',
+        tags: ['projects'],
+    }),
+    create: defineEndpoint({
+        method: 'POST',
+        path: '/projects',
+        body: CreateProjectInput,
+        response: CreateProjectResult,
+        summary: 'Create a new project (provisions infra asynchronously)',
+        tags: ['projects'],
+    }),
+    get: defineEndpoint({
+        method: 'GET',
+        path: '/projects/:id',
+        params: IdPath,
+        response: Project,
+        summary: 'Get project detail by id or slug',
+        tags: ['projects'],
+    }),
+    update: defineEndpoint({
+        method: 'PATCH',
+        path: '/projects/:id',
+        params: IdPath,
+        body: UpdateProjectInput,
+        response: Project,
+        summary: 'Update project metadata, webhooks, OAuth providers, or build machine tier',
+        tags: ['projects'],
+    }),
+    delete: defineEndpoint({
+        method: 'DELETE',
+        path: '/projects/:id',
+        params: IdPath,
+        response: DeleteProjectResult,
+        summary: 'Soft-delete a project — environments transition to `terminating`',
+        tags: ['projects'],
+    }),
+};

package/dist/endpoints/rate-limits.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Rate-Limits endpoints — BaaS-plane operator surface (ADR-089 Phase 5.2,
+ * Σ1 SoC rename).
+ *
+ * Previously mounted under `/auth/platform-rate-limits/*` (co-located
+ * with Phase 2b/c/d's Platform-audience AUTH endpoints). Σ1 moves these
+ * to their correct top-level namespace `/rate-limits/*` — rate-limiting
+ * is a cross-cutting BaaS primitive (operator config surface), not an
+ * auth verb.
+ *
+ * Server-side enforcement (`apps/runtime/.../routes/rate-limits.ts`):
+ *   - super_admin / admin → all scopes.
+ *   - project admin       → `project` + their project_id only.
+ *   - regular user        → `user` + their own user id only.
+ *   - scope escalation    → 403 `rate_limit_scope_forbidden`.
+ */
+export declare const rateLimitsEndpoints: {
+    readonly status: import("../endpoint.js").Endpoint<"GET", "/rate-limits/status", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        scope: import("effect/Schema").optional<import("effect/Schema").Literal<["global", "project", "user"]>>;
+        scope_id: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        namespace: import("effect/Schema").optional<import("effect/Schema").filter<typeof import("effect/Schema").String>>;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        rows: import("effect/Schema").Array$<import("effect/Schema").Struct<{
+            namespace: typeof import("effect/Schema").String;
+            scope: import("effect/Schema").Literal<["global", "project", "user"]>;
+            scopeId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            strategy: import("effect/Schema").Literal<["token-bucket", "sliding-window", "fixed-window"]>;
+            limit: typeof import("effect/Schema").Number;
+            windowSeconds: typeof import("effect/Schema").Number;
+            burst: import("effect/Schema").NullOr<typeof import("effect/Schema").Number>;
+            source: import("effect/Schema").Literal<["default", "global", "project", "user"]>;
+        }>>;
+    }>>;
+    readonly strategiesList: import("../endpoint.js").Endpoint<"GET", "/rate-limits/strategies", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        scope: import("effect/Schema").optional<import("effect/Schema").Literal<["global", "project", "user"]>>;
+        scope_id: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        strategies: import("effect/Schema").Array$<import("effect/Schema").Struct<{
+            id: typeof import("effect/Schema").String;
+            scope: import("effect/Schema").Literal<["global", "project", "user"]>;
+            scopeId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            namespace: typeof import("effect/Schema").String;
+            strategy: import("effect/Schema").Literal<["token-bucket", "sliding-window", "fixed-window"]>;
+            limitCount: typeof import("effect/Schema").Number;
+            windowSeconds: typeof import("effect/Schema").Number;
+            burstCount: import("effect/Schema").NullOr<typeof import("effect/Schema").Number>;
+            updatedAt: typeof import("effect/Schema").String;
+            updatedBy: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+        }>>;
+    }>>;
+    readonly strategyUpsert: import("../endpoint.js").Endpoint<"PUT", "/rate-limits/strategies/:namespace", import("effect/Schema").Struct<{
+        namespace: import("effect/Schema").filter<typeof import("effect/Schema").String>;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        scope: import("effect/Schema").Literal<["global", "project", "user"]>;
+        scope_id: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        strategy: import("effect/Schema").Literal<["token-bucket", "sliding-window", "fixed-window"]>;
+        limit: typeof import("effect/Schema").Number;
+        windowSeconds: typeof import("effect/Schema").Number;
+        burst: import("effect/Schema").optional<import("effect/Schema").NullOr<typeof import("effect/Schema").Number>>;
+    }>, import("effect/Schema").Struct<{
+        strategy: import("effect/Schema").Struct<{
+            id: typeof import("effect/Schema").String;
+            scope: import("effect/Schema").Literal<["global", "project", "user"]>;
+            scopeId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            namespace: typeof import("effect/Schema").String;
+            strategy: import("effect/Schema").Literal<["token-bucket", "sliding-window", "fixed-window"]>;
+            limitCount: typeof import("effect/Schema").Number;
+            windowSeconds: typeof import("effect/Schema").Number;
+            burstCount: import("effect/Schema").NullOr<typeof import("effect/Schema").Number>;
+            updatedAt: typeof import("effect/Schema").String;
+            updatedBy: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+        }>;
+    }>>;
+    readonly strategyDelete: import("../endpoint.js").Endpoint<"DELETE", "/rate-limits/strategies/:namespace", import("effect/Schema").Struct<{
+        namespace: import("effect/Schema").filter<typeof import("effect/Schema").String>;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        scope: import("effect/Schema").Literal<["global", "project", "user"]>;
+        scope_id: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        deleted: typeof import("effect/Schema").Boolean;
+    }>>;
+};
+//# sourceMappingURL=rate-limits.d.ts.map

package/dist/endpoints/rate-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limits.d.ts","sourceRoot":"","sources":["../../src/endpoints/rate-limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAeH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCtB,CAAA"}

package/dist/endpoints/rate-limits.js

@@ -0,0 +1,54 @@
+/**
+ * Rate-Limits endpoints — BaaS-plane operator surface (ADR-089 Phase 5.2,
+ * Σ1 SoC rename).
+ *
+ * Previously mounted under `/auth/platform-rate-limits/*` (co-located
+ * with Phase 2b/c/d's Platform-audience AUTH endpoints). Σ1 moves these
+ * to their correct top-level namespace `/rate-limits/*` — rate-limiting
+ * is a cross-cutting BaaS primitive (operator config surface), not an
+ * auth verb.
+ *
+ * Server-side enforcement (`apps/runtime/.../routes/rate-limits.ts`):
+ *   - super_admin / admin → all scopes.
+ *   - project admin       → `project` + their project_id only.
+ *   - regular user        → `user` + their own user id only.
+ *   - scope escalation    → 403 `rate_limit_scope_forbidden`.
+ */
+import { defineEndpoint } from '../endpoint.js';
+import { PlatformRateLimitNamespaceParams, PlatformRateLimitStatusRequest, PlatformRateLimitStatusResponse, PlatformRateLimitStrategiesListRequest, PlatformRateLimitStrategiesListResponse, PlatformRateLimitStrategyDeleteRequest, PlatformRateLimitStrategyDeleteResponse, PlatformRateLimitStrategyUpsertRequest, PlatformRateLimitStrategyUpsertResponse, } from '../schemas/auth.js';
+export const rateLimitsEndpoints = {
+    status: defineEndpoint({
+        method: 'GET',
+        path: '/rate-limits/status',
+        query: PlatformRateLimitStatusRequest,
+        response: PlatformRateLimitStatusResponse,
+        summary: 'Inspect effective rate-limit strategy for a namespace + caller scope',
+        tags: ['rate-limits'],
+    }),
+    strategiesList: defineEndpoint({
+        method: 'GET',
+        path: '/rate-limits/strategies',
+        query: PlatformRateLimitStrategiesListRequest,
+        response: PlatformRateLimitStrategiesListResponse,
+        summary: 'List installed rate-limit strategy overrides for a scope',
+        tags: ['rate-limits'],
+    }),
+    strategyUpsert: defineEndpoint({
+        method: 'PUT',
+        path: '/rate-limits/strategies/:namespace',
+        params: PlatformRateLimitNamespaceParams,
+        body: PlatformRateLimitStrategyUpsertRequest,
+        response: PlatformRateLimitStrategyUpsertResponse,
+        summary: 'Install / replace a rate-limit strategy override for a namespace',
+        tags: ['rate-limits'],
+    }),
+    strategyDelete: defineEndpoint({
+        method: 'DELETE',
+        path: '/rate-limits/strategies/:namespace',
+        params: PlatformRateLimitNamespaceParams,
+        body: PlatformRateLimitStrategyDeleteRequest,
+        response: PlatformRateLimitStrategyDeleteResponse,
+        summary: 'Delete a rate-limit strategy override, reverting to the code default',
+        tags: ['rate-limits'],
+    }),
+};

package/dist/endpoints/realtime-admin.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Realtime Admin endpoints — Console-plane dashboard over customer channels.
+ * Mirrors `apps/api/src/server/platform/routes/realtime.ts`.
+ *
+ * Production mount: `/realtime/*` on the management plane. The Platform
+ * route dogfoods BaaS via `@sylphx/sdk.realtime.admin.channels.*` which
+ * speaks to `/v1/realtime/admin/*` on the runtime (ADR-089 Phase 3a,
+ * renamed out of `/auth/platform-realtime/*` in Phase Σ1).
+ */
+export declare const realtimeAdminEndpoints: {
+    readonly getStatus: import("../endpoint.js").Endpoint<"GET", "/realtime/status", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        available: typeof import("effect/Schema").Boolean;
+        provider: typeof import("effect/Schema").String;
+    }>>;
+    readonly listChannels: import("../endpoint.js").Endpoint<"GET", "/realtime/channels", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        channels: import("effect/Schema").Array$<import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            activeConnections: typeof import("effect/Schema").Number;
+            messagesPerHour: typeof import("effect/Schema").Number;
+            status: import("effect/Schema").Literal<["active", "empty"]>;
+        }>>;
+        count: typeof import("effect/Schema").Number;
+    }>>;
+    readonly createChannel: import("../endpoint.js").Endpoint<"POST", "/realtime/channels", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+        name: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        name: typeof import("effect/Schema").String;
+    }>>;
+    readonly deleteChannel: import("../endpoint.js").Endpoint<"DELETE", "/realtime/channels/:channelName", import("effect/Schema").Struct<{
+        channelName: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        success: typeof import("effect/Schema").Boolean;
+    }>>;
+};
+//# sourceMappingURL=realtime-admin.d.ts.map

package/dist/endpoints/realtime-admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime-admin.d.ts","sourceRoot":"","sources":["../../src/endpoints/realtime-admin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCzB,CAAA"}

package/dist/endpoints/realtime-admin.js

@@ -0,0 +1,50 @@
+/**
+ * Realtime Admin endpoints — Console-plane dashboard over customer channels.
+ * Mirrors `apps/api/src/server/platform/routes/realtime.ts`.
+ *
+ * Production mount: `/realtime/*` on the management plane. The Platform
+ * route dogfoods BaaS via `@sylphx/sdk.realtime.admin.channels.*` which
+ * speaks to `/v1/realtime/admin/*` on the runtime (ADR-089 Phase 3a,
+ * renamed out of `/auth/platform-realtime/*` in Phase Σ1).
+ */
+import { defineEndpoint } from '../endpoint.js';
+import { RealtimeAdminChannelNameParams, RealtimeAdminCreateChannelInput, RealtimeAdminCreateChannelResult, RealtimeAdminDeleteChannelResult, RealtimeAdminListChannelsResult, RealtimeAdminProjectIdQuery, RealtimeAdminStatusResult, } from '../schemas/realtime-admin.js';
+export const realtimeAdminEndpoints = {
+    getStatus: defineEndpoint({
+        method: 'GET',
+        path: '/realtime/status',
+        query: RealtimeAdminProjectIdQuery,
+        response: RealtimeAdminStatusResult,
+        plane: 'management',
+        summary: 'Get realtime service status (always available via Redis Streams)',
+        tags: ['realtime-admin'],
+    }),
+    listChannels: defineEndpoint({
+        method: 'GET',
+        path: '/realtime/channels',
+        query: RealtimeAdminProjectIdQuery,
+        response: RealtimeAdminListChannelsResult,
+        plane: 'management',
+        summary: 'List realtime channels for a customer project',
+        tags: ['realtime-admin'],
+    }),
+    createChannel: defineEndpoint({
+        method: 'POST',
+        path: '/realtime/channels',
+        body: RealtimeAdminCreateChannelInput,
+        response: RealtimeAdminCreateChannelResult,
+        plane: 'management',
+        summary: 'Register a named realtime channel',
+        tags: ['realtime-admin'],
+    }),
+    deleteChannel: defineEndpoint({
+        method: 'DELETE',
+        path: '/realtime/channels/:channelName',
+        params: RealtimeAdminChannelNameParams,
+        query: RealtimeAdminProjectIdQuery,
+        response: RealtimeAdminDeleteChannelResult,
+        plane: 'management',
+        summary: 'Delete a realtime channel registration',
+        tags: ['realtime-admin'],
+    }),
+};

package/dist/endpoints/realtime.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Realtime endpoints — BaaS plane. `emit` + `history` are REST; the
+ * browser-facing `subscribe` transport is SSE and not modelled here
+ * (streaming responses are carried out-of-band by `@sylphx/sdk/react`).
+ */
+import { Schema } from 'effect';
+export declare const realtimeEndpoints: {
+    readonly emit: import("../endpoint.js").Endpoint<"POST", "/sdk/realtime/emit", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        channel: typeof Schema.String;
+        event: typeof Schema.String;
+        data: typeof Schema.Unknown;
+    }>, Schema.Struct<{
+        id: typeof Schema.String;
+        channel: typeof Schema.String;
+    }>>;
+    readonly history: import("../endpoint.js").Endpoint<"GET", "/sdk/realtime/history", Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        channel: typeof Schema.String;
+        limit: Schema.optional<typeof Schema.String>;
+        after: Schema.optional<typeof Schema.String>;
+    }>, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        messages: Schema.Array$<Schema.Struct<{
+            id: typeof Schema.String;
+            channel: typeof Schema.String;
+            event: typeof Schema.String;
+            data: typeof Schema.Unknown;
+            timestamp: typeof Schema.Number;
+        }>>;
+    }>>;
+    readonly subscribe: import("../endpoint.js").Endpoint<"GET", "/sdk/realtime/subscribe", Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        channel: typeof Schema.String;
+    }>, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        ok: typeof Schema.Boolean;
+    }>>;
+};
+//# sourceMappingURL=realtime.d.ts.map

package/dist/endpoints/realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../src/endpoints/realtime.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAS/B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BpB,CAAA"}

package/dist/endpoints/realtime.js

@@ -0,0 +1,39 @@
+/**
+ * Realtime endpoints — BaaS plane. `emit` + `history` are REST; the
+ * browser-facing `subscribe` transport is SSE and not modelled here
+ * (streaming responses are carried out-of-band by `@sylphx/sdk/react`).
+ */
+import { Schema } from 'effect';
+import { defineEndpoint } from '../endpoint.js';
+import { RealtimeEmitInput, RealtimeEmitResult, RealtimeHistoryQuery, RealtimeHistoryResult, } from '../schemas/realtime.js';
+export const realtimeEndpoints = {
+    emit: defineEndpoint({
+        method: 'POST',
+        path: '/sdk/realtime/emit',
+        body: RealtimeEmitInput,
+        response: RealtimeEmitResult,
+        plane: 'baas',
+        summary: 'Emit an event to a channel (fan-out to all SSE subscribers)',
+        tags: ['realtime'],
+    }),
+    history: defineEndpoint({
+        method: 'GET',
+        path: '/sdk/realtime/history',
+        query: RealtimeHistoryQuery,
+        response: RealtimeHistoryResult,
+        plane: 'baas',
+        summary: 'Replay historical messages from a channel',
+        tags: ['realtime'],
+    }),
+    subscribe: defineEndpoint({
+        method: 'GET',
+        path: '/sdk/realtime/subscribe',
+        query: Schema.Struct({ channel: Schema.String }),
+        // SSE stream — the contract surfaces only the initial envelope.
+        response: Schema.Struct({ ok: Schema.Boolean }),
+        plane: 'baas',
+        summary: 'Subscribe to a channel via SSE (text/event-stream)',
+        description: 'Transport is server-sent events. The response schema here is a placeholder; the real wire format is a stream of `StreamMessage` frames.',
+        tags: ['realtime'],
+    }),
+};