@oxy.so/contracts 4.17.0 → 4.22.0

package/dist/cjs/accountAccess.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Wire contract for `GET /internal/accounts/:accountId/access/:userId`: Oxy
+ * answers a trusted first-party service's question "may this person act FOR
+ * that account, and with what?" with no session of that person in the request.
+ *
+ * It exists for the account Oxy never lets anybody act AS: a `channel`
+ * ({@link isDelegatedActAsEligibleKind} refuses it). An app publishes to a
+ * channel with ITS OWN credential, on behalf of a member Oxy vouches for here,
+ * so nobody holds a bearer that speaks as the channel. A long-running import
+ * (Oxy Move) has only a service token and `X-Oxy-User-Id`, which the
+ * user-facing `GET /accounts/:id/members` refuses; this is its answer.
+ *
+ * Needs a service token whose application is platform-trusted AND holds the
+ * privileged {@link ACCOUNTS_MEMBERSHIP_READ_SCOPE}. The answer is always 200:
+ * `access` is `null` for no active membership, an archived account, an unknown
+ * account and an unclaimed directory account alike. Callers must treat every
+ * other status as a refusal (fail closed), and must not cache the answer longer
+ * than the action it authorizes.
+ *
+ * Platform-agnostic — zod only.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountAccessVerdictSchema = exports.accountAccessGrantSchema = exports.accountAccessSourceSchema = exports.ACCOUNT_ACCESS_SOURCES = exports.ACCOUNTS_MEMBERSHIP_READ_SCOPE = void 0;
+const zod_1 = require("zod");
+const accountGraph_1 = require("./accountGraph");
+/**
+ * The scope the endpoint requires.
+ *
+ * Privileged (staff-granted). Channel membership is sensitive because a channel
+ * is anonymous: its members are the people behind a voice that is published
+ * without their names, and "is this person a member of that channel" is
+ * exactly the fact the channel exists to withhold.
+ */
+exports.ACCOUNTS_MEMBERSHIP_READ_SCOPE = 'accounts:membership:read';
+/**
+ * Where the access comes from.
+ *
+ * - `self` — the person IS the account (a personal account asked about itself).
+ * - `direct` — an active membership row on the account.
+ * - `inherited` — an active, cascading membership on an ancestor account.
+ */
+exports.ACCOUNT_ACCESS_SOURCES = ['self', 'direct', 'inherited'];
+exports.accountAccessSourceSchema = zod_1.z.enum(exports.ACCOUNT_ACCESS_SOURCES);
+/**
+ * One person's EFFECTIVE access over one account.
+ *
+ * `role` and `permissions` are strings rather than closed enums on purpose: the
+ * role and permission vocabularies are the API's, they grow, and a consumer
+ * pinned to an older contracts release must keep reading new ones. Gate on
+ * `permissions` (the role's baseline adjusted by per-member grants and
+ * revokes), never on `role`.
+ */
+exports.accountAccessGrantSchema = zod_1.z.object({
+    role: zod_1.z.string().min(1),
+    permissions: zod_1.z.array(zod_1.z.string().min(1)),
+    /** Only an active membership grants access, so this is the one value. */
+    status: zod_1.z.literal('active'),
+    source: exports.accountAccessSourceSchema,
+});
+exports.accountAccessVerdictSchema = zod_1.z
+    .object({
+    accountId: zod_1.z.string().min(1),
+    /** `null` when no such account exists. */
+    kind: accountGraph_1.accountKindSchema.nullable(),
+    /** `null` means: this person may not act for this account. */
+    access: exports.accountAccessGrantSchema.nullable(),
+})
+    .refine((verdict) => verdict.access === null || verdict.kind !== null, {
+    message: 'An account that does not exist grants no access',
+    path: ['access'],
+});

package/dist/cjs/agency.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizedAppEventSchema = exports.catalogRegistrationSchema = exports.appCapabilityCatalogSchema = exports.catalogEventSchema = exports.catalogToolSchema = exports.auditEventSchema = exports.auditResultSchema = exports.policyDecisionSchema = exports.invocationPrincipalSchema = exports.capabilityTicketClaimsSchema = exports.automationDefinitionSchema = exports.automationDataFlowSchema = exports.automationActorSelectionSchema = exports.automationTriggerSchema = exports.delegationGrantSchema = exports.capabilityTicketRequestSchema = exports.capabilityCoordinatorSchema = exports.executionAuthorizationRefSchema = exports.capabilityCatalogBindingSchema = exports.grantLimitSchema = exports.toolGrantOverrideSchema = exports.resourceRefSchema = exports.foregroundExecutionAuthorizationInputSchema = exports.executionActorRefSchema = exports.actorRefSchema = exports.capabilityPackageSchema = exports.CAPABILITY_PACKAGES = exports.autonomyLevelSchema = exports.AUTONOMY_LEVELS = void 0;
+exports.normalizedAppEventSchema = exports.catalogRegistrationSchema = exports.appCapabilityCatalogSchema = exports.CATALOG_INTERNAL_TRANSPORTS = exports.catalogFeatureSchema = exports.catalogEventSchema = exports.catalogToolSchema = exports.auditEventSchema = exports.auditResultSchema = exports.policyDecisionSchema = exports.invocationPrincipalSchema = exports.capabilityTicketClaimsSchema = exports.automationDefinitionSchema = exports.automationDataFlowSchema = exports.automationActorSelectionSchema = exports.automationTriggerSchema = exports.agentRequesterCeilingSchema = exports.agentRequesterCeilingWriteSchema = exports.AGENT_REQUESTER_CEILING_AUTONOMY = exports.delegationGrantSchema = exports.capabilityTicketRequestSchema = exports.capabilityCoordinatorSchema = exports.executionAuthorizationRefSchema = exports.capabilityCatalogBindingSchema = exports.grantLimitSchema = exports.toolGrantOverrideSchema = exports.resourceRefSchema = exports.foregroundExecutionAuthorizationInputSchema = exports.executionActorRefSchema = exports.actorRefSchema = exports.capabilityPackageSchema = exports.CAPABILITY_PACKAGES = exports.autonomyLevelSchema = exports.AUTONOMY_LEVELS = void 0;
 const zod_1 = require("zod");
 const capabilityInvocation_1 = require("./capabilityInvocation");
 const nonEmptyStringSchema = zod_1.z.string().trim().min(1);
@@ -143,6 +143,35 @@ exports.delegationGrantSchema = zod_1.z
     updatedAt: zod_1.z.string().datetime(),
 })
     .strict();
+/**
+ * The two levels an owner publishes for whoever uses their agent (ADR 0042):
+ * "Ver" and "Ver y actuar". A ceiling never says `draft` or `execute_on_request`:
+ * an agent is either allowed to act on its own or not at all, and nothing ever
+ * asks the person for approval.
+ */
+exports.AGENT_REQUESTER_CEILING_AUTONOMY = ['read_only', 'autonomous'];
+/** What an agent may do in one app for whoever uses it; written by an operator of the bot. */
+exports.agentRequesterCeilingWriteSchema = zod_1.z
+    .object({
+    capabilityPackages: zod_1.z.array(exports.capabilityPackageSchema),
+    capabilities: zod_1.z.array(identifierSchema).default([]),
+    toolOverrides: zod_1.z.array(exports.toolGrantOverrideSchema).default([]),
+    limits: zod_1.z.array(exports.grantLimitSchema).default([]),
+    maximumAutonomy: zod_1.z.enum(exports.AGENT_REQUESTER_CEILING_AUTONOMY),
+})
+    .strict();
+exports.agentRequesterCeilingSchema = exports.agentRequesterCeilingWriteSchema
+    .extend({
+    id: identifierSchema,
+    agentAccountId: identifierSchema,
+    appId: identifierSchema,
+    catalog: exports.capabilityCatalogBindingSchema,
+    version: zod_1.z.number().int().positive(),
+    revokedAt: zod_1.z.string().datetime().nullable(),
+    createdAt: zod_1.z.string().datetime(),
+    updatedAt: zod_1.z.string().datetime(),
+})
+    .strict();
 exports.automationTriggerSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal('manual') }).strict(),
     zod_1.z
@@ -204,6 +233,8 @@ exports.capabilityTicketClaimsSchema = zod_1.z
     /** Signed only for callers that explicitly requested a pinned catalogue. */
     catalog: exports.capabilityCatalogBindingSchema.optional(),
     grantId: identifierSchema.optional(),
+    /** The owner's published ceiling that bounds an agent acting for a non-owner (ADR 0042). */
+    ceilingId: identifierSchema.optional(),
     requesterAccountId: identifierSchema,
     ownerAccountId: identifierSchema,
     actor: exports.executionActorRefSchema,
@@ -242,6 +273,24 @@ exports.capabilityTicketClaimsSchema = zod_1.z
             message: 'requester actors require their exact principal and direct read-only authority without standing grants',
         });
     }
+    if (claims.ceilingId !== undefined) {
+        if (claims.grantId !== undefined) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['ceilingId'],
+                message: 'a ticket is bounded by either a grant or a ceiling, never both',
+            });
+        }
+        if (claims.actor.type !== 'agent' ||
+            claims.ownerAccountId !== claims.requesterAccountId ||
+            claims.resource.resourceId !== claims.resource.effectiveAccountId) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['ceilingId'],
+                message: "a ceiling bounds an agent acting on the requester's own authority at an account root",
+            });
+        }
+    }
     if (claims.exp <= claims.iat) {
         context.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
@@ -303,6 +352,7 @@ exports.policyDecisionSchema = zod_1.z
     reason: identifierSchema,
     effectiveAutonomy: exports.autonomyLevelSchema.optional(),
     grantId: identifierSchema.optional(),
+    ceilingId: identifierSchema.optional(),
 })
     .strict();
 exports.auditResultSchema = zod_1.z
@@ -512,6 +562,24 @@ exports.catalogEventSchema = zod_1.z
     resourceTypes: zod_1.z.array(identifierSchema).min(1),
 })
     .strict();
+/**
+ * A feature an agent may gate on (Alia ADR 0020 §6): the app answers whether the
+ * person may use it (`checkTool`) and, when using it costs something, spends it
+ * (`consumeTool`). Both are internal tools of the same catalogue.
+ */
+exports.catalogFeatureSchema = zod_1.z
+    .object({
+    key: zod_1.z
+        .string()
+        .regex(/^[a-z][a-z0-9_-]*(?:\.[a-z][a-z0-9_-]*)*$/, 'feature keys are dot-separated slugs')
+        .max(128),
+    description: nonEmptyStringSchema,
+    checkTool: identifierSchema,
+    consumeTool: identifierSchema.optional(),
+})
+    .strict();
+/** How a coordinator reaches the catalogue's internal tools. */
+exports.CATALOG_INTERNAL_TRANSPORTS = ['http', 'mcp'];
 exports.appCapabilityCatalogSchema = zod_1.z
     .object({
     schemaVersion: zod_1.z.literal('1'),
@@ -567,11 +635,54 @@ exports.appCapabilityCatalogSchema = zod_1.z
     })
         .strict()
         .optional(),
+    /**
+     * `mcp`: internal tools are served at `<internalBaseUrl>/_oxy/mcp`. Absent or
+     * `http`: each tool's `invocation` path on `internalBaseUrl`.
+     */
+    internalTransport: zod_1.z.enum(exports.CATALOG_INTERNAL_TRANSPORTS).optional(),
+    features: zod_1.z.array(exports.catalogFeatureSchema).optional(),
     tools: zod_1.z.array(exports.catalogToolSchema),
     events: zod_1.z.array(exports.catalogEventSchema),
 })
     .strict()
     .superRefine((catalog, context) => {
+    const toolsByName = new Map(catalog.tools.map((tool) => [tool.name, tool]));
+    const featureKeys = new Set();
+    for (const [index, feature] of (catalog.features ?? []).entries()) {
+        if (featureKeys.has(feature.key)) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Duplicate feature key: ${feature.key}`,
+                path: ['features', index, 'key'],
+            });
+        }
+        featureKeys.add(feature.key);
+        const check = toolsByName.get(feature.checkTool);
+        if (!check ||
+            check.effect !== 'read' ||
+            check.exposure.length !== 1 ||
+            check.exposure[0] !== 'internal') {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: 'checkTool must name an internal-only read tool of this catalogue',
+                path: ['features', index, 'checkTool'],
+            });
+        }
+        if (feature.consumeTool !== undefined) {
+            const consume = toolsByName.get(feature.consumeTool);
+            if (!consume ||
+                consume.effect === 'read' ||
+                consume.idempotency !== 'required' ||
+                consume.exposure.length !== 1 ||
+                consume.exposure[0] !== 'internal') {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: 'consumeTool must name an internal-only effectful tool that requires idempotency keys',
+                    path: ['features', index, 'consumeTool'],
+                });
+            }
+        }
+    }
     const names = new Set();
     for (const [index, tool] of catalog.tools.entries()) {
         if (names.has(tool.name)) {

package/dist/cjs/applicationRoles.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Application roles — the wire contract for permissions an APPLICATION declares
+ * about its own users, and for the grants that give them to Oxy users.
+ *
+ * Oxy decides who holds an app's operator powers (who may run Mercaria's
+ * payments desk, moderate GoWay, administer Homiio), so no app keeps an
+ * allow-list of Oxy user ids in its environment. The app declares a closed
+ * vocabulary of keys, its owners grant them to people, and the app's backend
+ * asks Oxy which of them the human behind a request holds
+ * (`GET /applications/:appId/roles/me`, read through `@oxy.so/core/server`).
+ *
+ * ## Why an application key can never collide with an Oxy permission
+ *
+ * Every permission Oxy itself checks (`app:update`, `apps:create`,
+ * `credentials:rotate`, every scope) is spelled with a COLON. An application key
+ * is dot-separated lowercase segments and cannot contain one, so the two
+ * vocabularies are disjoint by syntax, not by convention. They are also stored
+ * apart (scoped to one application id) and no Oxy gate ever reads an
+ * application key. A key means something only to the application that declared
+ * it.
+ *
+ * The pattern is exported as a SOURCE string because the API renders the same
+ * text into a Postgres CHECK; JavaScript's `RegExp` and Postgres' ARE agree on
+ * everything it uses (anchors, classes, a capturing group, a bounded repeat).
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationRolesMeSchema = exports.listApplicationRoleGrantsQuerySchema = exports.revokeApplicationRoleGrantRequestSchema = exports.createApplicationRoleGrantRequestSchema = exports.applicationRoleGrantListSchema = exports.applicationRoleGrantSchema = exports.declareApplicationPermissionsResponseSchema = exports.applicationPermissionListSchema = exports.applicationPermissionSchema = exports.declareApplicationPermissionsRequestSchema = exports.applicationPermissionDeclarationSchema = exports.applicationPermissionKeySchema = exports.APPLICATION_ROLE_ERROR_CODES = exports.APPLICATION_ROLE_GRANTS_PAGE_MAX = exports.APPLICATION_ROLE_GRANTS_PAGE_DEFAULT = exports.APPLICATION_ROLE_REASON_MAX_LENGTH = exports.APPLICATION_PERMISSIONS_MAX_DECLARED = exports.APPLICATION_PERMISSION_DESCRIPTION_MAX_LENGTH = exports.APPLICATION_PERMISSION_KEY_MAX_LENGTH = exports.APPLICATION_PERMISSION_KEY_PATTERN = exports.APPLICATION_PERMISSION_KEY_PATTERN_SOURCE = void 0;
+exports.isApplicationPermissionKey = isApplicationPermissionKey;
+const zod_1 = require("zod");
+/**
+ * Two to four dot-separated segments, each a lowercase letter followed by
+ * lowercase letters, digits or underscores: `payments.operate`,
+ * `catalog.review.publish`. At least two segments so a key always names an
+ * area and an action; never a colon (see the header).
+ */
+exports.APPLICATION_PERMISSION_KEY_PATTERN_SOURCE = '^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*){1,3}$';
+exports.APPLICATION_PERMISSION_KEY_PATTERN = new RegExp(exports.APPLICATION_PERMISSION_KEY_PATTERN_SOURCE);
+exports.APPLICATION_PERMISSION_KEY_MAX_LENGTH = 64;
+exports.APPLICATION_PERMISSION_DESCRIPTION_MAX_LENGTH = 280;
+/** How many live keys one application may declare. Operator powers are few. */
+exports.APPLICATION_PERMISSIONS_MAX_DECLARED = 64;
+exports.APPLICATION_ROLE_REASON_MAX_LENGTH = 500;
+exports.APPLICATION_ROLE_GRANTS_PAGE_DEFAULT = 50;
+exports.APPLICATION_ROLE_GRANTS_PAGE_MAX = 200;
+/**
+ * The `error` codes the application-roles routes answer beyond the generic
+ * ones (`BAD_REQUEST`, `UNAUTHORIZED`, `FORBIDDEN`, `NOT_FOUND`). Renaming one
+ * is a breaking change.
+ */
+exports.APPLICATION_ROLE_ERROR_CODES = {
+    /** 403: a grant naming yourself on an application you do not own outright. */
+    selfGrantForbidden: 'SELF_GRANT_FORBIDDEN',
+    /** 422: the key is not a live declared permission of this application. */
+    unknownPermission: 'UNKNOWN_PERMISSION',
+    /** 422: the grantee is not a person (an organization, project, bot or channel). */
+    granteeNotAPerson: 'GRANTEE_NOT_A_PERSON',
+    /** 409: the grantee already holds the key; `details.grantId` names the live grant. */
+    alreadyGranted: 'ALREADY_GRANTED',
+    /** 409: the grant was already revoked. */
+    alreadyRevoked: 'ALREADY_REVOKED',
+    /** 403: the bearer's session belongs to a DIFFERENT application. */
+    sessionApplicationMismatch: 'SESSION_APPLICATION_MISMATCH',
+};
+/** Whether `value` is a well-formed application permission key. */
+function isApplicationPermissionKey(value) {
+    return (typeof value === 'string' &&
+        value.length <= exports.APPLICATION_PERMISSION_KEY_MAX_LENGTH &&
+        exports.APPLICATION_PERMISSION_KEY_PATTERN.test(value));
+}
+exports.applicationPermissionKeySchema = zod_1.z
+    .string()
+    .max(exports.APPLICATION_PERMISSION_KEY_MAX_LENGTH)
+    .regex(exports.APPLICATION_PERMISSION_KEY_PATTERN, 'A permission key is 2-4 dot-separated lowercase segments, e.g. payments.operate');
+/** Plain text: no control characters other than a newline or a tab. */
+function plainText(max) {
+    return zod_1.z
+        .string()
+        .trim()
+        .min(1)
+        .max(max)
+        .refine((value) => Array.from(value).every((character) => {
+        const code = character.charCodeAt(0);
+        return (code >= 32 && code !== 127) || character === '\n' || character === '\t';
+    }), 'Must be plain text');
+}
+const id = zod_1.z.string().min(1).max(128);
+const isoTimestamp = zod_1.z.string().min(1);
+const reasonSchema = plainText(exports.APPLICATION_ROLE_REASON_MAX_LENGTH);
+/** One key as the application's owners declare it. */
+exports.applicationPermissionDeclarationSchema = zod_1.z
+    .object({
+    key: exports.applicationPermissionKeySchema,
+    description: plainText(exports.APPLICATION_PERMISSION_DESCRIPTION_MAX_LENGTH),
+})
+    .strict();
+/**
+ * `PUT /applications/:appId/roles/permissions` — the WHOLE vocabulary.
+ *
+ * Declarative: a key present here and not live is added, a live key absent
+ * here is retired (and every grant of it revoked), a live key present here
+ * keeps its identity and takes the new description. Sending the same body twice
+ * changes nothing.
+ */
+exports.declareApplicationPermissionsRequestSchema = zod_1.z
+    .object({
+    permissions: zod_1.z
+        .array(exports.applicationPermissionDeclarationSchema)
+        .max(exports.APPLICATION_PERMISSIONS_MAX_DECLARED),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const seen = new Set();
+    value.permissions.forEach((permission, index) => {
+        if (seen.has(permission.key)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['permissions', index, 'key'],
+                message: `Duplicate permission key ${permission.key}`,
+            });
+        }
+        seen.add(permission.key);
+    });
+});
+/** A declared key. Retired keys are history: they confer nothing. */
+exports.applicationPermissionSchema = zod_1.z.object({
+    key: exports.applicationPermissionKeySchema,
+    description: zod_1.z.string(),
+    declaredAt: isoTimestamp,
+    declaredByUserId: id.nullable(),
+    retiredAt: isoTimestamp.nullable(),
+    retiredByUserId: id.nullable(),
+});
+exports.applicationPermissionListSchema = zod_1.z.object({
+    items: zod_1.z.array(exports.applicationPermissionSchema),
+});
+exports.declareApplicationPermissionsResponseSchema = exports.applicationPermissionListSchema.extend({
+    /** Keys that became live with this declaration. */
+    added: zod_1.z.array(exports.applicationPermissionKeySchema),
+    /** Keys this declaration retired. */
+    retired: zod_1.z.array(exports.applicationPermissionKeySchema),
+    /** Live keys whose description changed. */
+    described: zod_1.z.array(exports.applicationPermissionKeySchema),
+    /** Live grants revoked because their key was retired. */
+    revokedGrants: zod_1.z.number().int().nonnegative(),
+});
+/** One grant of one key to one Oxy user. Revocation is a stamp, never a delete. */
+exports.applicationRoleGrantSchema = zod_1.z.object({
+    id,
+    applicationId: id,
+    permission: exports.applicationPermissionKeySchema,
+    userId: id,
+    /** The grantee's handle, for display. */
+    username: zod_1.z.string().nullable(),
+    /** The HUMAN who granted it; null once that account was erased. */
+    grantedByUserId: id.nullable(),
+    grantedAt: isoTimestamp,
+    grantReason: zod_1.z.string().nullable(),
+    revokedAt: isoTimestamp.nullable(),
+    revokedByUserId: id.nullable(),
+    revokeReason: zod_1.z.string().nullable(),
+});
+exports.applicationRoleGrantListSchema = zod_1.z.object({
+    items: zod_1.z.array(exports.applicationRoleGrantSchema),
+    nextCursor: zod_1.z.string().nullable(),
+});
+/** `POST /applications/:appId/roles/grants` — name the grantee by id OR handle. */
+exports.createApplicationRoleGrantRequestSchema = zod_1.z
+    .object({
+    userId: id.optional(),
+    username: zod_1.z.string().trim().min(1).max(64).optional(),
+    permission: exports.applicationPermissionKeySchema,
+    reason: reasonSchema.optional(),
+})
+    .strict()
+    .refine((value) => (value.userId === undefined) !== (value.username === undefined), {
+    message: 'Name the grantee with exactly one of userId or username',
+    path: ['userId'],
+});
+/** `POST /applications/:appId/roles/grants/:grantId/revoke`. */
+exports.revokeApplicationRoleGrantRequestSchema = zod_1.z
+    .object({
+    reason: reasonSchema.optional(),
+})
+    .strict();
+/** `GET /applications/:appId/roles/grants` query. */
+exports.listApplicationRoleGrantsQuerySchema = zod_1.z
+    .object({
+    permission: exports.applicationPermissionKeySchema.optional(),
+    userId: id.optional(),
+    includeRevoked: zod_1.z
+        .enum(['true', 'false'])
+        .transform((value) => value === 'true')
+        .optional(),
+    limit: zod_1.z.coerce.number().int().min(1).max(exports.APPLICATION_ROLE_GRANTS_PAGE_MAX).optional(),
+    cursor: zod_1.z.string().min(1).max(512).optional(),
+})
+    .strict();
+/**
+ * `GET /applications/:appId/roles/me` — the keys the HUMAN behind the bearer
+ * holds for this application, in no particular order. `userId` is that human
+ * (the operator), which is NOT the account the session speaks as when a person
+ * is acting as an organization.
+ */
+exports.applicationRolesMeSchema = zod_1.z.object({
+    applicationId: id,
+    userId: id,
+    permissions: zod_1.z.array(exports.applicationPermissionKeySchema),
+});

package/dist/cjs/client/check.js

@@ -25,6 +25,7 @@
  *   strictObject(shape)   unknown keys FAIL (`.strict()`)
  *   looseObject(shape)    unknown keys are KEPT (`.passthrough()`)
  *   refine(c, test)       a further condition, run once `c` passes
+ *   transform(c, f)       `f` rewrites the value once `c` passes
  *   union / discriminatedUnion   as Zod 3 reports them
  *
  * A failure carries the first issue Zod would report and whether Zod would have
@@ -52,6 +53,7 @@ exports.nullable = nullable;
 exports.withDefault = withDefault;
 exports.refine = refine;
 exports.refineAt = refineAt;
+exports.transform = transform;
 exports.branded = branded;
 exports.minItems = minItems;
 exports.maxItems = maxItems;
@@ -265,6 +267,13 @@ function refineAt(inner, test) {
             : checked;
     };
 }
+/** Zod's `.transform()`: rewrites a value `inner` accepted. */
+function transform(inner, rewrite) {
+    return (input, path) => {
+        const checked = inner(input, path);
+        return checked.ok ? ok(rewrite(checked.value)) : checked;
+    };
+}
 /** Narrows a checked value to a branded contract type (Zod's `.brand()`). */
 function branded(inner) {
     return inner;

package/dist/cjs/client/contentClaims.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Content claims (ADR 0043 D10) — the constants of the public "Report content
+ * / rights claim" intake and of a claim's review, without Zod. Schemas:
+ * `../contentClaims.ts`.
+ *
+ * Part of `@oxy.so/contracts/client`: never import `zod` here (see `./check.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COUNTER_NOTICE_STATEMENT_VERSION = exports.COUNTER_NOTICE_STATEMENTS = exports.CONTENT_CLAIM_COUNTER_NOTICE_LIMITS = exports.CONTENT_CLAIM_REFERENCE_PATTERN = exports.CONTENT_CLAIM_ERROR_CODES = exports.ERASURE_REQUEST_DEADLINE_DAYS = exports.CLOSED_CONTENT_CLAIM_STATES = exports.OPEN_CONTENT_CLAIM_STATES = exports.CONTENT_CLAIM_STATES = exports.CONTENT_CLAIM_LIMITS = exports.CLAIMANT_RELATIONSHIPS = exports.CONTENT_CLAIM_KINDS = void 0;
+exports.isRightsClaim = isRightsClaim;
+exports.isErasureRequest = isErasureRequest;
+/** What a claim asserts. */
+exports.CONTENT_CLAIM_KINDS = [
+    'copyright',
+    'trademark',
+    'privacy',
+    'illegal_content',
+    'other',
+];
+/** Who the claimant is to the content. */
+exports.CLAIMANT_RELATIONSHIPS = [
+    'rights_holder',
+    'authorized_agent',
+    'affected_person',
+    'other',
+];
+/** The bounds of a submission. The website fills its validation messages from these. */
+exports.CONTENT_CLAIM_LIMITS = {
+    minUrls: 1,
+    maxUrls: 20,
+    maxUrlLength: 2048,
+    minDescription: 20,
+    maxDescription: 5000,
+    maxName: 200,
+    maxOrganization: 200,
+    maxEmail: 254,
+};
+/**
+ * Where a claim is in its review.
+ *
+ * `received → reviewing → actioned | rejected`; an actioned claim can be
+ * answered by the content's owner (`counter_noticed`), which ends either in
+ * `reinstated` (the content is served again) or `upheld` (it stays blocked).
+ * A claim can also be rejected straight from `received`.
+ */
+exports.CONTENT_CLAIM_STATES = [
+    'received',
+    'reviewing',
+    'actioned',
+    'rejected',
+    'counter_noticed',
+    'reinstated',
+    'upheld',
+];
+/** The states in which a claim is still open: its evidence is kept and its blocks can change. */
+exports.OPEN_CONTENT_CLAIM_STATES = [
+    'received',
+    'reviewing',
+    'actioned',
+    'counter_noticed',
+];
+/** The states a claim ends in. */
+exports.CLOSED_CONTENT_CLAIM_STATES = [
+    'rejected',
+    'reinstated',
+    'upheld',
+];
+/**
+ * The kinds whose claimant asserts a right in a work or a mark. Only these
+ * carry the link to the original — a privacy or illegal-content report
+ * asserts no ownership.
+ */
+function isRightsClaim(kind) {
+    return kind === 'copyright' || kind === 'trademark';
+}
+/**
+ * A request to erase the claimant's OWN personal data (GDPR art. 17): a
+ * privacy claim made by the person it is about. Oxy must answer it within one
+ * month (art. 12(3)); the claim carries that deadline.
+ */
+function isErasureRequest(kind, relationship) {
+    return kind === 'privacy' && relationship === 'affected_person';
+}
+/** Days Oxy has to answer an erasure request ({@link isErasureRequest}). */
+exports.ERASURE_REQUEST_DEADLINE_DAYS = 30;
+/**
+ * Stable error codes a takedown produces elsewhere in the API. A file whose
+ * bytes are on the blocklist cannot be uploaded, imported or copied by anyone
+ * (HTTP 451).
+ */
+exports.CONTENT_CLAIM_ERROR_CODES = {
+    /** The submission failed validation; `fields` names each problem. */
+    invalid: 'CONTENT_CLAIM_INVALID',
+    /** These exact bytes were taken down after a claim and cannot be stored again. */
+    contentBlocked: 'CONTENT_BLOCKED',
+    /** A counter-notice failed validation; `fields` names each problem. */
+    counterNoticeInvalid: 'CONTENT_CLAIM_COUNTER_NOTICE_INVALID',
+    /** The files named are blocked by more than one claim: name the claim's reference. */
+    counterNoticeAmbiguous: 'CONTENT_CLAIM_COUNTER_NOTICE_AMBIGUOUS',
+    /** This account already sent a counter-notice for this claim. */
+    counterNoticeExists: 'CONTENT_CLAIM_COUNTER_NOTICE_EXISTS',
+};
+/**
+ * A claim's reference as the claimant and the owner are sent it:
+ * `OXY-XXXX-XXXX`, Crockford base32 (no I, L, O or U).
+ */
+exports.CONTENT_CLAIM_REFERENCE_PATTERN = /^OXY-[0-9A-HJKMNP-TV-Z]{4}-[0-9A-HJKMNP-TV-Z]{4}$/;
+/** The bounds of an owner's counter-notice. The website fills its validation messages from these. */
+exports.CONTENT_CLAIM_COUNTER_NOTICE_LIMITS = {
+    maxFileIds: 50,
+    maxFileId: 64,
+    maxName: 200,
+    maxAddress: 500,
+    minPhone: 5,
+    maxPhone: 40,
+    maxEmail: 254,
+    minMaterial: 10,
+    maxMaterial: 2000,
+    maxLocation: 2048,
+    minExplanation: 20,
+    maxExplanation: 5000,
+    maxSignature: 200,
+};
+/**
+ * The statements an owner's counter-notice makes, word for word — what the
+ * form shows beside each box (17 U.S.C. § 512(g)(3)(C) and (D), and what Oxy
+ * does with the notice). The API records {@link COUNTER_NOTICE_STATEMENT_VERSION}
+ * with every notice, so the wording a person agreed to can always be told
+ * apart from a later one. Change the text only together with the version.
+ */
+exports.COUNTER_NOTICE_STATEMENTS = {
+    perjury: 'I swear, under penalty of perjury, that I have a good faith belief that the material identified above was removed or disabled as a result of a mistake or misidentification of the material to be removed or disabled.',
+    jurisdiction: 'I consent to the jurisdiction of the Federal District Court for the judicial district in which my address is located or, if my address is outside of the United States, any judicial district in which Oxy may be found.',
+    serviceOfProcess: 'I will accept service of process from the person who provided the notification of the claimed infringement, or an agent of such person.',
+    disclosure: 'I understand that Oxy sends a copy of this counter-notice, including my name and contact details, to the person who made the claim, as the law requires.',
+};
+/** The version of {@link COUNTER_NOTICE_STATEMENTS} in force. */
+exports.COUNTER_NOTICE_STATEMENT_VERSION = '2026-10-16';