@segmentstream-cloud/ontology 0.25.1 → 0.26.1

package/dist/runtime/sql-runtime.js

@@ -1,9 +1,11 @@
-import { Effect, Option } from "effect";
+import { Effect, Exit, Option } from "effect";
 import { beginReplicationWrite } from "../replication/transaction.js";
 import { isSqlError } from "effect/unstable/sql/SqlError";
-import { Conflict } from "../errors.js";
+import { ActionRejected, Conflict } from "../errors.js";
 import { toSnakeCase } from "../names.js";
 import { User } from "../user.js";
+import { ACTION_MAX_BATCH_ROWS, BATCH_MAX_BYTES, BATCH_MAX_ROWS, batchInputBytes, executeBatch, planBatch, } from "./batch.js";
+import { logBatchConflict } from "./batch-diagnostics.js";
 import { InvalidQuery, WriteOutsideAction } from "./errors.js";
 import { entityModel, ontologyModel } from "./model.js";
 import { loadRecord, notFound, readHistory, relatedCondition, runQuery, validateQuery, } from "./reads.js";
@@ -23,7 +25,7 @@ function withoutUndefined(value) {
         .map(([key, entry]) => [key, withoutUndefined(entry)]));
 }
 /** A unique violation becomes Conflict, naming the property when the index covers one column. */
-function uniqueConflict(entity, error) {
+function uniqueConflict(entity, error, batch) {
     const cause = (error.reason.cause ?? {});
     const unique = error.reason._tag === "UniqueViolation" || cause.code === "23505";
     if (!unique) {
@@ -31,17 +33,36 @@ function uniqueConflict(entity, error) {
     }
     const columns = typeof cause.detail === "string" ? /^Key \(([^)]*)\)=/.exec(cause.detail)?.[1] : undefined;
     const field = entity.fields.find((candidate) => candidate.column === columns);
+    const fields = typeof columns === "string"
+        ? columns.split(", ").flatMap((column) => {
+            const candidate = entity.fields.find((entry) => entry.column === column);
+            return candidate === undefined ? [] : [candidate.relationship ?? candidate.name];
+        })
+        : [];
+    const details = batch ? { batch: { indices: [], ...(fields.length > 0 ? { fields } : {}) } } : {};
     const label = entity.label.toLowerCase();
-    return Effect.fail(field === undefined
+    const conflict = field === undefined
         ? new Conflict({
             entity: entity.name,
             message: `The ${label} conflicts with an existing one.`,
+            ...details,
         })
         : new Conflict({
             entity: entity.name,
             property: field.name,
             message: `A ${label} with this ${field.name} already exists.`,
-        }));
+            ...details,
+        });
+    if (batch) {
+        // Keep the driver's complete cause available to operators without serializing SQL or values.
+        Object.defineProperty(conflict, "cause", { value: error, enumerable: false });
+        return logBatchConflict(entity, error, {
+            operation: batch.operation,
+            action: batch.scope.action,
+            actionId: batch.scope.actionId,
+        }).pipe(Effect.andThen(Effect.fail(conflict)));
+    }
+    return Effect.fail(conflict);
 }
 /**
  * Platform identity bookkeeping touches only User properties and their history. User is excluded
@@ -91,6 +112,8 @@ export function makeOntologyRuntime(ontology, sql, scope) {
         run: (text, params) => client.unsafe(text, params.values),
     };
     const entityOf = (name) => Effect.sync(() => entityModel(model, name));
+    let attemptedBatchRows = 0;
+    let attributionInitialized = false;
     const write = (entityName, operation) => Effect.gen(function* () {
         const entity = yield* entityOf(entityName);
         if (scope === undefined) {
@@ -108,14 +131,111 @@ export function makeOntologyRuntime(ontology, sql, scope) {
         for (const edit of edits) {
             scope.onEdit?.(edit);
         }
+        if (edits.length > 0 && scope.execution !== undefined) {
+            attributionInitialized = true;
+        }
         return result;
     });
+    const batch = (entityName, operation, input) => Effect.suspend(() => {
+        const startedAt = Date.now();
+        let statements = 0;
+        let distinctReferences = 0;
+        let counts = { created: 0, updated: 0, unchanged: 0 };
+        const run = Effect.gen(function* () {
+            if (scope === undefined) {
+                return yield* Effect.die(new WriteOutsideAction({
+                    entity: entityName,
+                    message: `Writes to ${entityName} run inside an action, which history records.`,
+                }));
+            }
+            const declared = ontology.entities.find((entity) => entity.name === entityName);
+            if (declared?.builtIn === true || declared?.entity.definition.source !== undefined) {
+                return yield* new ActionRejected({
+                    message: "Batch writes require an ordinary stored entity.",
+                    batch: { indices: [] },
+                });
+            }
+            const entity = yield* entityOf(entityName);
+            const length = input.records.length;
+            if (length > 0) {
+                attemptedBatchRows += length;
+            }
+            if (length > BATCH_MAX_ROWS || (length > 0 && attemptedBatchRows > ACTION_MAX_BATCH_ROWS)) {
+                return yield* new ActionRejected({
+                    message: length > BATCH_MAX_ROWS
+                        ? `A batch accepts at most ${BATCH_MAX_ROWS} records.`
+                        : `An action accepts at most ${ACTION_MAX_BATCH_ROWS} attempted batch records.`,
+                    batch: { indices: [] },
+                });
+            }
+            if (batchInputBytes(input) > BATCH_MAX_BYTES) {
+                return yield* new ActionRejected({
+                    message: `A batch accepts at most ${BATCH_MAX_BYTES} UTF-8 JSON bytes.`,
+                    batch: { indices: [] },
+                });
+            }
+            const plan = yield* planBatch(entity, operation, input);
+            distinctReferences = plan.distinctReferences;
+            if (length === 0) {
+                return plan.returning === "summary" ? counts : { ...counts, items: [] };
+            }
+            const enclosingTransaction = yield* Effect.serviceOption(sql.transactionService);
+            if (Option.isNone(enclosingTransaction)) {
+                return yield* Effect.die(new WriteOutsideAction({
+                    entity: entityName,
+                    message: "Batch writes require the enclosing action transaction.",
+                }));
+            }
+            const edits = [];
+            statements += 1; // The SQL client's nested transaction issues one savepoint.
+            const result = yield* sql
+                .withTransaction((scope.replicationInitialized ? Effect.void : beginReplicationWrite(sql)).pipe(Effect.andThen(executeBatch({
+                ...context,
+                scope,
+                edits,
+                attributionInitialized,
+                run: (text, params) => {
+                    statements += 1;
+                    return context.run(text, params);
+                },
+            }, entity, plan)), Effect.onExit((exit) => Effect.sync(() => {
+                if (Exit.isFailure(exit)) {
+                    statements += 1; // A failed nested transaction rolls back to its savepoint.
+                }
+            }))))
+                .pipe(Effect.catchIf(isSqlError, (error) => uniqueConflict(entity, error, { operation, scope })));
+            counts = { created: result.created, updated: result.updated, unchanged: result.unchanged };
+            for (const edit of edits) {
+                scope.onEdit?.(edit);
+            }
+            if (edits.length > 0 && scope.execution !== undefined) {
+                attributionInitialized = true;
+            }
+            return result;
+        });
+        return run.pipe(Effect.onExit((exit) => Effect.logDebug("ontology.action.batch_completed").pipe(Effect.annotateLogs({
+            operation,
+            entity: entityName,
+            action: scope?.action,
+            actionId: scope?.actionId,
+            inputCount: input.records.length,
+            distinctReferenceCount: distinctReferences,
+            changedCount: counts.created + counts.updated,
+            unchangedCount: counts.unchanged,
+            sqlStatements: statements,
+            batchMs: Date.now() - startedAt,
+            outcome: Exit.isSuccess(exit) ? "success" : "failure",
+        }))));
+    });
     const query = (input) => Effect.gen(function* () {
         const entity = yield* entityOf(input.entity);
         const validated = yield* validateQuery(entity, input.query);
         return yield* orDieOnSql(runQuery(context, entity, validated));
     });
     return {
+        createMany: ((input) => batch(input.entity, "create", input)),
+        updateMany: ((input) => batch(input.entity, "update", input)),
+        upsertMany: ((input) => batch(input.entity, "upsert", input)),
         get: (input) => orDieOnSql(Effect.gen(function* () {
             const entity = yield* entityOf(input.entity);
             const record = yield* loadRecord(context, entity, input.id, input.forUpdate === true ? "update" : undefined);

package/dist/runtime.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect } from "effect";
-import type { Conflict, NotFound } from "./errors.js";
+import type { ActionRejected, Conflict, NotFound } from "./errors.js";
 import type { Where } from "./query.js";
 import type { WorkloadExecution } from "./runtime/workload.js";
 /** Who runs an action: an app member or a service principal, both `user` records. */
@@ -76,6 +76,51 @@ export interface UpsertResult<R = StoredRecord> {
     readonly record: R;
     readonly created: boolean;
 }
+/** Whether a batch returns its records or only outcome counts. Defaults to `records`. */
+export type BatchReturning = "records" | "summary";
+export interface BatchOptions {
+    readonly returning?: BatchReturning;
+}
+/** Outcome counts, which together equal the number of inputs in a successful batch. */
+export interface BatchSummaryResult {
+    readonly created: number;
+    readonly updated: number;
+    readonly unchanged: number;
+}
+/** One result per input, in input order, including records whose values did not change. */
+export interface BatchRecordResult<R = StoredRecord> extends BatchSummaryResult {
+    readonly items: ReadonlyArray<{
+        readonly index: number;
+        readonly status: "created" | "updated" | "unchanged";
+        readonly record: R;
+    }>;
+}
+export type BatchResult<R = StoredRecord> = BatchRecordResult<R> | BatchSummaryResult;
+/** Raw batch inputs use wire entity and field names. */
+export interface CreateManyInput extends BatchOptions {
+    readonly entity: string;
+    readonly records: ReadonlyArray<StoredValues>;
+}
+export interface UpdateManyInput extends BatchOptions {
+    readonly entity: string;
+    readonly records: ReadonlyArray<{
+        readonly id: string;
+        readonly values: StoredValues;
+    }>;
+}
+export interface UpsertManyInput extends CreateManyInput {
+    readonly on: readonly [string, ...string[]];
+}
+type BatchWriteError = ActionRejected | Conflict | NotFound;
+interface BatchWrite<Input extends BatchOptions> {
+    (input: Input & {
+        readonly returning: "summary";
+    }): Effect.Effect<BatchSummaryResult, BatchWriteError>;
+    (input: Input & {
+        readonly returning?: "records";
+    }): Effect.Effect<BatchRecordResult, BatchWriteError>;
+    (input: Input): Effect.Effect<BatchResult, BatchWriteError>;
+}
 type ReadsService = {
     readonly get: (input: {
         readonly entity: string;
@@ -88,6 +133,9 @@ type ReadsService = {
     }) => Effect.Effect<ReadonlyArray<StoredRecord>>;
 };
 type WritesService = {
+    readonly createMany: BatchWrite<CreateManyInput>;
+    readonly updateMany: BatchWrite<UpdateManyInput>;
+    readonly upsertMany: BatchWrite<UpsertManyInput>;
     readonly create: (input: {
         readonly entity: string;
         readonly values: StoredValues;
@@ -130,7 +178,8 @@ export declare class OntologyReads extends OntologyReads_base {
 declare const OntologyWrites_base: Context.ServiceClass<OntologyWrites, "@segmentstream-cloud/ontology/OntologyWrites", WritesService>;
 /**
  * The writes an action handler runs, inside the action's transaction: `create`, `update`,
- * `upsertBy`, `delete`, `link` and `unlink` of entity handles require it. `prepare` never has it.
+ * `upsertBy`, the batch methods, `delete`, `link` and `unlink` of entity handles require it.
+ * `prepare` never has it.
  */
 export declare class OntologyWrites extends OntologyWrites_base {
 }

package/dist/runtime.js

@@ -8,7 +8,8 @@ export class OntologyReads extends Context.Service()("@segmentstream-cloud/ontol
 }
 /**
  * The writes an action handler runs, inside the action's transaction: `create`, `update`,
- * `upsertBy`, `delete`, `link` and `unlink` of entity handles require it. `prepare` never has it.
+ * `upsertBy`, the batch methods, `delete`, `link` and `unlink` of entity handles require it.
+ * `prepare` never has it.
  */
 export class OntologyWrites extends Context.Service()("@segmentstream-cloud/ontology/OntologyWrites") {
 }

package/dist/service/errors.js

@@ -1,6 +1,7 @@
 import { Cause, Context, Effect, Option, Predicate, Schema, SchemaIssue } from "effect";
 import { HttpServerResponse } from "effect/unstable/http";
 import { HttpApiError } from "effect/unstable/httpapi";
+import { BatchErrorDetails } from "../errors.js";
 /** The correlation id of the current request, in every error body and the `x-request-id` header. */
 export class RequestId extends Context.Service()("@segmentstream-cloud/ontology/RequestId") {
 }
@@ -64,6 +65,19 @@ function listed(values) {
         ? values.join("")
         : `${values.slice(0, -1).join(", ")} and ${values.at(-1)}`;
 }
+/** Only the declared safe locations cross a transport, even for structurally tagged failures. */
+function batchDetails(error) {
+    const batch = error.batch;
+    if (!Schema.is(BatchErrorDetails)(batch)) {
+        return {};
+    }
+    return {
+        batch: {
+            indices: batch.indices,
+            ...(batch.fields === undefined ? {} : { fields: batch.fields }),
+        },
+    };
+}
 export function toServerResponse(response) {
     return HttpServerResponse.jsonUnsafe(errorBodyForWire(response.body), {
         status: response.status,
@@ -323,6 +337,7 @@ export function expectedFailure(error, requestId) {
                 detail: message,
                 requestId,
                 issues: [{ path: [], message }],
+                ...batchDetails(error),
             },
         };
     }
@@ -421,6 +436,7 @@ export function expectedFailure(error, requestId) {
                 requestId,
                 ...(typeof entity === "string" ? { entity } : {}),
                 ...(typeof id === "string" ? { id } : {}),
+                ...batchDetails(error),
             },
         };
     }
@@ -434,6 +450,7 @@ export function expectedFailure(error, requestId) {
                 requestId,
                 ...(typeof entity === "string" ? { entity } : {}),
                 ...(typeof property === "string" ? { property } : {}),
+                ...batchDetails(error),
             },
         };
     }

package/dist/service/mcp/server.js

@@ -17,6 +17,7 @@ import { OntologyBackend } from "../runtime-contract.js";
 import { runtimeCredential } from "../runtime-identity.js";
 import { ActionResponse, HistoryPage, HistoryParams, IdParam, Me, } from "../schemas.js";
 import { uploadFields } from "../../storage/attachments.js";
+import { memberFileOperations } from "../member-files.js";
 import { ACTION_OPTIONS_ARGUMENT, mcpTools, visibleTools } from "./tools.js";
 /** The URL path of the ontology's MCP server, outside `/api/ontology`: one per app. */
 export const MCP_PATH = "/mcp";
@@ -169,7 +170,7 @@ function toolFailure(cause, requestId) {
         isError: true,
     }));
 }
-function runTool({ built, operations, aggregate, conversations }, tool, args, request) {
+function runTool({ built, operations, aggregate, conversations, memberFiles }, tool, args, request) {
     return Effect.gen(function* () {
         const { target } = tool;
         switch (target.kind) {
@@ -197,6 +198,8 @@ function runTool({ built, operations, aggregate, conversations }, tool, args, re
                 const { id } = yield* decodeArguments(GetArguments, args);
                 return structured(yield* encoded(schemas.record, yield* operations.get(target.planned, id)));
             }
+            case "member-file":
+                return structured(yield* memberFiles(target.operation, args, identityToken(request)));
             case "conversation-search": {
                 const search = yield* decodeArguments(ConversationSearch, args);
                 const principal = yield* CurrentPrincipal;
@@ -463,14 +466,19 @@ function handlePost(server, verifyToken, verifyRuntime, backend) {
  * authentication. `GET` and `DELETE`, which open a server stream and end a session, answer 405.
  */
 export function mcpLayer(options) {
-    const tools = mcpTools(options.built, options.conversations !== undefined);
     return Layer.effectDiscard(Effect.gen(function* () {
         const router = yield* HttpRouter.HttpRouter;
         const backend = yield* OntologyBackend;
+        const tools = mcpTools(options.built, options.conversations !== undefined, {
+            attachments: backend.attachments !== undefined,
+            files: backend.blobs !== undefined,
+        });
+        const operations = makeOperations(backend, options.built.plan, options.hooks, options.connections, options.replicate, options.agentChannel);
         const server = {
             built: options.built,
             tools,
-            operations: makeOperations(backend, options.built.plan, options.hooks, options.connections, options.replicate, options.agentChannel),
+            operations,
+            memberFiles: memberFileOperations(backend, options.built.plan, operations),
             aggregate: options.aggregates.model,
             conversations: options.conversations,
         };

package/dist/service/mcp/tools.d.ts

@@ -1,5 +1,6 @@
 import type { JsonSchemaObject } from "../../analyze.js";
 import { type PermissionHolder } from "../../permissions.js";
+import { type MemberFileOperation } from "../member-files.js";
 import type { BuiltApi } from "../api.js";
 import type { PlannedAction, PlannedEntity } from "../plan.js";
 /** How a tool behaves, as MCP's tool annotations say it. */
@@ -28,6 +29,9 @@ export type McpToolTarget = {
     readonly kind: "aggregate";
 } | {
     readonly kind: "conversation-search";
+} | {
+    readonly kind: "member-file";
+    readonly operation: MemberFileOperation;
 };
 /** A tool of the ontology's MCP server, derived from the same plan as the HTTP routes. */
 export interface McpTool {
@@ -60,7 +64,10 @@ export declare const ACTION_OPTIONS_ARGUMENT = "_options";
  * as they have no record routes. Throws {@link InvalidOntology} when two tools share a name, which
  * `check` already refuses.
  */
-export declare function mcpTools(built: BuiltApi, conversations?: boolean): ReadonlyArray<McpTool>;
+export declare function mcpTools(built: BuiltApi, conversations?: boolean, storage?: {
+    attachments?: boolean;
+    files?: boolean;
+}): ReadonlyArray<McpTool>;
 /**
  * The tools a caller may see: those whose every permission the caller's roles grant, each with the
  * caller's input schema.

package/dist/service/mcp/tools.js

@@ -8,6 +8,7 @@ import { queryJsonSchema } from "../../query.js";
 import { measureDescription, measuresFor, modelMeasureDescription, modelMeasuresFor, RECORDS_OR_AGGREGATES, } from "../../render.js";
 import { actionInputJsonSchema } from "../../runtime/generated-actions.js";
 import { uploadFields } from "../../storage/attachments.js";
+import { MEMBER_FILE_SCHEMAS } from "../member-files.js";
 import { actionDescription, requires } from "../descriptions.js";
 import { AGGREGATE_FILTER_OPERATORS, AGGREGATE_GRANULARITIES, AGGREGATE_LIMITS, AGGREGATE_PERIOD_UNITS, AGGREGATE_PERIODS, HistoryPage, MAXIMUM_TIMEZONE_LENGTH, Me, } from "../schemas.js";
 const DEFS = "#/$defs/";
@@ -424,7 +425,7 @@ function aggregateTool(manifest) {
  * as they have no record routes. Throws {@link InvalidOntology} when two tools share a name, which
  * `check` already refuses.
  */
-export function mcpTools(built, conversations = false) {
+export function mcpTools(built, conversations = false, storage = {}) {
     const { manifest } = built.plan.ontology;
     const tools = [
         ...GLOBAL_TOOLS,
@@ -482,6 +483,39 @@ export function mcpTools(built, conversations = false) {
             target: { kind: "conversation-search" },
         });
     }
+    const descriptions = {
+        "attachments-list": "List chat attachments by conversation (provider:chat ID), sender member UUID and ISO time range. " +
+            "Returns a bounded page and nextCursor; use before to resume. Includes expired metadata. " +
+            "Administrators with agent_chat:update may access any workspace chat; active group participants " +
+            "and DM senders may access their files.",
+        "attachments-get": "Read metadata of an accessible chat attachment. Expired or purged attachments return a clear error.",
+        "attachments-download": "Download an accessible chat attachment. Returns filename, content type, size, SHA-256 and a " +
+            "short-lived GET grant. Stream the URL's bytes with its supplied headers before expiry; do not " +
+            "forward your app bearer token.",
+        "attachments-promote": "Keep a chat attachment through an ontology action such as document.upload. Supply the action " +
+            "input without the file; the platform adopts the stored revision, fills SHA-256 when declared, " +
+            "and enforces your current action permissions. Retries reuse the promotion result.",
+        "files-download": "Download a stored blob property of a record you may read. property defaults to content. Returns " +
+            "immutable revision metadata, filename, content type, size, SHA-256 and a short-lived GET grant. " +
+            "Stream bytes from the URL with its supplied headers before expiry; do not forward your app " +
+            "bearer token.",
+    };
+    for (const operation of Object.keys(MEMBER_FILE_SCHEMAS)) {
+        if (operation === "files-download" ? !storage.files : !storage.attachments) {
+            continue;
+        }
+        tools.push({
+            name: operation.replaceAll("-", "_"),
+            title: operation.replaceAll("-", " "),
+            description: descriptions[operation],
+            inputSchema: encodedJsonSchema(MEMBER_FILE_SCHEMAS[operation]),
+            annotations: operation === "attachments-promote"
+                ? { readOnlyHint: false, idempotentHint: true, openWorldHint: true }
+                : READ,
+            permissions: [],
+            target: { kind: "member-file", operation },
+        });
+    }
     const seen = new Set();
     const duplicates = tools.filter(({ name }) => seen.size === seen.add(name).size);
     if (duplicates.length > 0) {

package/dist/service/member-file-routes.d.ts

@@ -0,0 +1,22 @@
+import { Layer } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import { type SessionExchange, type TokenVerifier } from "./authentication.js";
+import type { AgentChannelFactory } from "./agent/channel.js";
+import type { AfterCommitHook } from "./config.js";
+import type { ConnectionTransportFactory } from "./connections.js";
+import type { ApiPlan } from "./plan.js";
+import type { ReplicationKick } from "./replication.js";
+import { RequestId } from "./errors.js";
+import { OntologyBackend } from "./runtime-contract.js";
+interface MemberFileRoutesOptions {
+    readonly plan: ApiPlan;
+    readonly hooks: ReadonlyMap<string, AfterCommitHook>;
+    readonly connections: ConnectionTransportFactory;
+    readonly replicate: ReplicationKick;
+    readonly agentChannel?: AgentChannelFactory | undefined;
+    readonly verifyToken: TokenVerifier;
+    readonly exchangeSession?: SessionExchange | undefined;
+}
+/** Authenticated users use these routes; the agent's receive/discard routes stay runtime-owned. */
+export declare function memberFileRoutes(options: MemberFileRoutesOptions): Layer.Layer<never, never, OntologyBackend | HttpRouter.HttpRouter | HttpRouter.Request<"Requires", RequestId>>;
+export {};

package/dist/service/member-file-routes.js

@@ -0,0 +1,52 @@
+import { Cause, Effect, Layer } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder, HttpApiSecurity } from "effect/unstable/httpapi";
+import { withPrincipal } from "./authentication.js";
+import { InvalidRequestBody, RequestId, failureResponse } from "./errors.js";
+import { identityToken, makeOperations } from "./operations.js";
+import { memberFileOperations } from "./member-files.js";
+import { OntologyBackend } from "./runtime-contract.js";
+/** Authenticated users use these routes; the agent's receive/discard routes stay runtime-owned. */
+export function memberFileRoutes(options) {
+    return Layer.effectDiscard(Effect.gen(function* () {
+        const router = yield* HttpRouter.HttpRouter;
+        const backend = yield* OntologyBackend;
+        const run = memberFileOperations(backend, options.plan, makeOperations(backend, options.plan, options.hooks, options.connections, options.replicate, options.agentChannel));
+        const route = (kind) => (request) => Effect.gen(function* () {
+            const bearer = yield* HttpApiBuilder.securityDecode(HttpApiSecurity.bearer).pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, request));
+            const operation = Effect.gen(function* () {
+                const params = yield* HttpRouter.params;
+                let args = params;
+                if (kind === "attachments-list") {
+                    const query = Object.fromEntries(new URL(request.url, "https://app.invalid").searchParams);
+                    args = {
+                        ...query,
+                        ...(query.limit === undefined ? {} : { limit: Number(query.limit) }),
+                    };
+                }
+                else if (kind === "attachments-promote") {
+                    const body = yield* request.json.pipe(Effect.mapError(() => new InvalidRequestBody({ reason: "invalid_json", issues: [] })));
+                    args =
+                        typeof body === "object" && body !== null && !Array.isArray(body)
+                            ? { ...body, id: params.id }
+                            : body;
+                }
+                const answer = yield* run(kind, args, identityToken(request));
+                return HttpServerResponse.jsonUnsafe(answer, {
+                    headers: { "cache-control": "private, no-store" },
+                });
+            }).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+                ? Effect.failCause(cause)
+                : Effect.flatMap(RequestId, (id) => failureResponse(cause, id))));
+            return yield* withPrincipal(bearer, options.verifyToken, backend, operation, {
+                session: { request, exchange: options.exchangeSession },
+            });
+        });
+        yield* router.add("GET", "/api/ontology/attachments", route("attachments-list"));
+        yield* router.add("GET", "/api/ontology/attachments/:id", route("attachments-get"));
+        yield* router.add("GET", "/api/ontology/attachments/:id/download", route("attachments-download"));
+        yield* router.add("POST", "/api/ontology/attachments/:id/promote", route("attachments-promote"));
+        yield* router.add("GET", "/api/ontology/files/:entity/:id/:property", route("files-download"));
+        yield* router.add("GET", "/api/ontology/files/:entity/:id", route("files-download"));
+    }));
+}