@oxy.so/contracts 4.15.0 → 4.17.0

package/dist/cjs/client/check.js

@@ -0,0 +1,466 @@
+"use strict";
+/**
+ * Structural checks for contract values, without Zod.
+ *
+ * The Zod schemas in this package are the contract, and the API parses with
+ * them. A client only needs to know that a response has the shape its type
+ * promises, and Zod's object schemas pull Zod's whole runtime into every app
+ * that bundles the SDK (~120 KB before compression, evaluated at startup). The
+ * checks here give the client the same answers in plain TypeScript.
+ *
+ * Every check mirrors one Zod 3 schema in this package, and
+ * `__tests__/clientChecks.parity.test.ts` runs both over the same inputs and
+ * requires the same verdict, the same output and the same failing path. The
+ * rules follow Zod 3 exactly:
+ *
+ *   string(...rules)      a string; `trim`/`toLowerCase` rewrite it, the other
+ *                         rules test it, in the order given
+ *   number(...rules)      a number that is not NaN (Infinity passes, as in Zod)
+ *   literal(v) / oneOf    `===` one value / one of a fixed set of strings
+ *   optional(c)           `undefined` (or an absent key) passes; `null` does not
+ *   nullable(c)           `null` passes and is kept
+ *   withDefault(c, v)     `undefined` becomes `v`, which is then checked
+ *   array(c, ...rules)    the size rules first, then every element in order
+ *   object(shape)         unknown keys are DROPPED (Zod's default "strip")
+ *   strictObject(shape)   unknown keys FAIL (`.strict()`)
+ *   looseObject(shape)    unknown keys are KEPT (`.passthrough()`)
+ *   refine(c, test)       a further condition, run once `c` passes
+ *   union / discriminatedUnion   as Zod 3 reports them
+ *
+ * A failure carries the first issue Zod would report and whether Zod would have
+ * stopped there (`fatal`: the type was wrong) or kept checking (`fatal: false`:
+ * only a rule failed). Only `union` reads the difference, because Zod reports a
+ * union through its first "rule failed" option.
+ *
+ * This module, and everything under `src/client/`, must never import `zod`
+ * (`__tests__/clientEntryGraph.test.ts` walks the graph).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractCheckError = exports.unknownRecord = exports.boolean = exports.safe = exports.nonnegative = exports.positive = exports.int = exports.datetime = exports.url = exports.email = exports.toLowerCase = exports.trim = void 0;
+exports.minLength = minLength;
+exports.maxLength = maxLength;
+exports.pattern = pattern;
+exports.startsWith = startsWith;
+exports.string = string;
+exports.atLeast = atLeast;
+exports.atMost = atMost;
+exports.number = number;
+exports.literal = literal;
+exports.oneOf = oneOf;
+exports.optional = optional;
+exports.nullable = nullable;
+exports.withDefault = withDefault;
+exports.refine = refine;
+exports.refineAt = refineAt;
+exports.branded = branded;
+exports.minItems = minItems;
+exports.maxItems = maxItems;
+exports.exactItems = exactItems;
+exports.array = array;
+exports.object = object;
+exports.strictObject = strictObject;
+exports.looseObject = looseObject;
+exports.union = union;
+exports.discriminatedUnion = discriminatedUnion;
+exports.formatCheckPath = formatCheckPath;
+exports.checkContract = checkContract;
+exports.parseContract = parseContract;
+exports.exact = exact;
+function ok(value) {
+    return { ok: true, value };
+}
+function fail(path, problem, fatal) {
+    return { ok: false, issue: { path, ...problem }, fatal };
+}
+function describe(input) {
+    if (input === null)
+        return 'null';
+    if (Array.isArray(input))
+        return 'array';
+    if (typeof input === 'number' && Number.isNaN(input))
+        return 'nan';
+    return typeof input;
+}
+/** Zod's wording for a value of the wrong type. */
+function wrongType(path, expected, input) {
+    const received = describe(input);
+    const message = input === undefined ? 'Required' : `Expected ${expected}, received ${received}`;
+    return fail(path, { code: 'invalid_type', message, expected, received }, true);
+}
+/** `'a' | 'b'` — how Zod lists allowed values. */
+function listValues(values, separator = ' | ') {
+    return values
+        .map((value) => (typeof value === 'string' ? `'${value}'` : String(value)))
+        .join(separator);
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+exports.trim = { rewrite: (value) => value.trim() };
+exports.toLowerCase = { rewrite: (value) => value.toLowerCase() };
+function minLength(min, message) {
+    return {
+        test: (value) => value.length >= min,
+        code: 'too_small',
+        message: message ?? `String must contain at least ${min} character(s)`,
+    };
+}
+function maxLength(max, message) {
+    return {
+        test: (value) => value.length <= max,
+        code: 'too_big',
+        message: message ?? `String must contain at most ${max} character(s)`,
+    };
+}
+function pattern(regex, message) {
+    return {
+        test: (value) => {
+            regex.lastIndex = 0;
+            return regex.test(value);
+        },
+        code: 'invalid_string',
+        message: message ?? 'Invalid',
+    };
+}
+function startsWith(prefix) {
+    return {
+        test: (value) => value.startsWith(prefix),
+        code: 'invalid_string',
+        message: `Invalid input: must start with "${prefix}"`,
+    };
+}
+/** Zod 3's `.email()`. */
+const EMAIL = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9-]*\.)+[A-Z]{2,}$/i;
+exports.email = pattern(EMAIL, 'Invalid email');
+/** Zod 3's `.url()`: anything `new URL()` accepts. */
+exports.url = {
+    test: (value) => {
+        try {
+            new URL(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    code: 'invalid_string',
+    message: 'Invalid url',
+};
+/** Zod 3's `.datetime()`: ISO 8601 in UTC (`Z`), any sub-second precision, leap days checked. */
+const DATETIME = new RegExp('^((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))' +
+    'T([01]\\d|2[0-3]):[0-5]\\d(:[0-5]\\d(\\.\\d+)?)?(Z)$');
+exports.datetime = pattern(DATETIME, 'Invalid datetime');
+function string(...rules) {
+    return (input, path) => {
+        if (typeof input !== 'string')
+            return wrongType(path, 'string', input);
+        let value = input;
+        let firstFailure = null;
+        for (const rule of rules) {
+            if ('rewrite' in rule)
+                value = rule.rewrite(value);
+            else if (firstFailure === null && !rule.test(value)) {
+                firstFailure = { code: rule.code, message: rule.message };
+            }
+        }
+        return firstFailure === null ? ok(value) : fail(path, firstFailure, false);
+    };
+}
+/** Zod's `.int()` — reported, as Zod does, as an `invalid_type` that does not stop the parse. */
+const int = (value) => Number.isInteger(value)
+    ? undefined
+    : {
+        code: 'invalid_type',
+        message: 'Expected integer, received float',
+        expected: 'integer',
+        received: 'float',
+    };
+exports.int = int;
+function atLeast(min) {
+    return (value) => value >= min
+        ? undefined
+        : { code: 'too_small', message: `Number must be greater than or equal to ${min}` };
+}
+function atMost(max) {
+    return (value) => value <= max
+        ? undefined
+        : { code: 'too_big', message: `Number must be less than or equal to ${max}` };
+}
+/** Zod's `.positive()`. */
+const positive = (value) => value > 0 ? undefined : { code: 'too_small', message: 'Number must be greater than 0' };
+exports.positive = positive;
+/** Zod's `.nonnegative()` (and `.min(0)`). */
+exports.nonnegative = atLeast(0);
+/** Zod's `.safe()`: both bounds, low first. */
+const safe = (value) => atLeast(Number.MIN_SAFE_INTEGER)(value) ?? atMost(Number.MAX_SAFE_INTEGER)(value);
+exports.safe = safe;
+function number(...rules) {
+    return (input, path) => {
+        if (typeof input !== 'number' || Number.isNaN(input))
+            return wrongType(path, 'number', input);
+        for (const rule of rules) {
+            const problem = rule(input);
+            if (problem)
+                return fail(path, problem, false);
+        }
+        return ok(input);
+    };
+}
+const boolean = (input, path) => typeof input === 'boolean' ? ok(input) : wrongType(path, 'boolean', input);
+exports.boolean = boolean;
+function literal(expected) {
+    return (input, path) => input === expected
+        ? ok(expected)
+        : fail(path, {
+            code: 'invalid_literal',
+            message: `Invalid literal value, expected ${JSON.stringify(expected)}`,
+        }, true);
+}
+/** One of a fixed set of strings — Zod's `z.enum`. */
+function oneOf(values) {
+    return (input, path) => {
+        if (typeof input !== 'string')
+            return wrongType(path, listValues(values), input);
+        return values.includes(input)
+            ? ok(input)
+            : fail(path, {
+                code: 'invalid_enum_value',
+                message: `Invalid enum value. Expected ${listValues(values)}, received '${input}'`,
+            }, true);
+    };
+}
+/* -------------------------------------------------------------------------- */
+/*  Wrappers                                                                  */
+/* -------------------------------------------------------------------------- */
+function optional(inner) {
+    return (input, path) => (input === undefined ? ok(undefined) : inner(input, path));
+}
+function nullable(inner) {
+    return (input, path) => (input === null ? ok(null) : inner(input, path));
+}
+function withDefault(inner, fallback) {
+    return (input, path) => inner(input === undefined ? fallback : input, path);
+}
+/** A further condition on a value `inner` accepted. */
+function refine(inner, test, message) {
+    return (input, path) => {
+        const checked = inner(input, path);
+        if (!checked.ok)
+            return checked;
+        return test(checked.value) ? checked : fail(path, { code: 'custom', message }, false);
+    };
+}
+/**
+ * Zod's `.superRefine()` for the one-issue case: `test` returns the first
+ * problem (its path relative to the value) or `undefined`.
+ */
+function refineAt(inner, test) {
+    return (input, path) => {
+        const checked = inner(input, path);
+        if (!checked.ok)
+            return checked;
+        const problem = test(checked.value);
+        return problem
+            ? fail([...path, ...problem.path], { code: 'custom', message: problem.message }, false)
+            : checked;
+    };
+}
+/** Narrows a checked value to a branded contract type (Zod's `.brand()`). */
+function branded(inner) {
+    return inner;
+}
+/**
+ * The issues of a container, as Zod 3 orders them: the first one is reported,
+ * and the container is fatal when any part of it was.
+ */
+class Failures {
+    constructor(first) {
+        this.fatal = false;
+        this.first = first;
+    }
+    add(failure) {
+        this.first ?? (this.first = failure.issue);
+        this.fatal || (this.fatal = failure.fatal);
+    }
+    result() {
+        return this.first ? { ok: false, issue: this.first, fatal: this.fatal } : null;
+    }
+}
+function minItems(min) {
+    return {
+        test: (length) => length >= min,
+        code: 'too_small',
+        message: `Array must contain at least ${min} element(s)`,
+    };
+}
+function maxItems(max) {
+    return {
+        test: (length) => length <= max,
+        code: 'too_big',
+        message: `Array must contain at most ${max} element(s)`,
+    };
+}
+/** Zod's `.length(n)`: `too_big` or `too_small`, by which side it missed. */
+function exactItems(count) {
+    const message = `Array must contain exactly ${count} element(s)`;
+    return [
+        { test: (length) => length <= count, code: 'too_big', message },
+        { test: (length) => length >= count, code: 'too_small', message },
+    ];
+}
+function array(inner, ...rules) {
+    const sizeRules = rules.flat();
+    return (input, path) => {
+        if (!Array.isArray(input))
+            return wrongType(path, 'array', input);
+        // Zod reports the size before any element, then every element in order.
+        const size = sizeRules.find((rule) => !rule.test(input.length));
+        const failures = new Failures(size ? { path, code: size.code, message: size.message } : null);
+        const out = [];
+        for (let index = 0; index < input.length; index++) {
+            const checked = inner(input[index], [...path, index]);
+            if (checked.ok)
+                out.push(checked.value);
+            else
+                failures.add(checked);
+        }
+        return failures.result() ?? ok(out);
+    };
+}
+function objectWith(shape, unknownKeys) {
+    const keys = Object.keys(shape);
+    return (input, path) => {
+        if (!isRecord(input))
+            return wrongType(path, 'object', input);
+        const failures = new Failures(null);
+        const out = {};
+        for (const key of keys) {
+            const checked = shape[key](input[key], [...path, key]);
+            if (!checked.ok)
+                failures.add(checked);
+            // An optional key the input did not send stays absent rather than
+            // appearing as `key: undefined` — what Zod does, and what `in` sees.
+            else if (key !== '__proto__' && (checked.value !== undefined || key in input)) {
+                out[key] = checked.value;
+            }
+        }
+        if (unknownKeys !== 'strip') {
+            const unknown = [];
+            for (const key in input) {
+                if (keys.includes(key))
+                    continue;
+                unknown.push(key);
+                if (unknownKeys === 'passthrough' && key !== '__proto__' && input[key] !== undefined) {
+                    out[key] = input[key];
+                }
+            }
+            if (unknownKeys === 'strict' && unknown.length > 0) {
+                const message = `Unrecognized key(s) in object: ${listValues(unknown, ', ')}`;
+                failures.add({ issue: { path, code: 'unrecognized_keys', message }, fatal: false });
+            }
+        }
+        return failures.result() ?? ok(out);
+    };
+}
+/** Unknown keys are dropped — Zod's `z.object(shape)`. */
+function object(shape) {
+    return objectWith(shape, 'strip');
+}
+/** Unknown keys fail — Zod's `z.object(shape).strict()`. */
+function strictObject(shape) {
+    return objectWith(shape, 'strict');
+}
+/** Unknown keys are kept as sent — Zod's `z.object(shape).passthrough()`. */
+function looseObject(shape) {
+    return objectWith(shape, 'passthrough');
+}
+/** Any object, every value kept — Zod's `z.record(z.unknown())`. */
+const unknownRecord = (input, path) => {
+    if (!isRecord(input))
+        return wrongType(path, 'object', input);
+    const out = {};
+    for (const key in input)
+        if (key !== '__proto__')
+            out[key] = input[key];
+    return ok(out);
+};
+exports.unknownRecord = unknownRecord;
+/* -------------------------------------------------------------------------- */
+/*  Unions                                                                    */
+/* -------------------------------------------------------------------------- */
+/** The first option that passes; else Zod 3's report (the first option that only failed a rule). */
+function union(...options) {
+    return (input, path) => {
+        let ruleFailure = null;
+        for (const option of options) {
+            const checked = option(input, path);
+            if (checked.ok)
+                return checked;
+            if (!checked.fatal)
+                ruleFailure ?? (ruleFailure = checked);
+        }
+        return ruleFailure ?? fail(path, { code: 'invalid_union', message: 'Invalid input' }, true);
+    };
+}
+/** Zod 3's `z.discriminatedUnion(key, options)`, with the options keyed by their tag. */
+function discriminatedUnion(key, options) {
+    return (input, path) => {
+        if (!isRecord(input))
+            return wrongType(path, 'object', input);
+        const tag = input[key];
+        const option = typeof tag === 'string' && Object.prototype.hasOwnProperty.call(options, tag)
+            ? options[tag]
+            : undefined;
+        if (!option) {
+            const message = `Invalid discriminator value. Expected ${listValues(Object.keys(options))}`;
+            return fail([...path, key], { code: 'invalid_union_discriminator', message }, true);
+        }
+        return option(input, path);
+    };
+}
+/* -------------------------------------------------------------------------- */
+/*  Using a check                                                             */
+/* -------------------------------------------------------------------------- */
+/** `a.b[0].c` — for messages. */
+function formatCheckPath(path) {
+    let out = '';
+    for (const part of path) {
+        out += typeof part === 'number' ? `[${part}]` : out ? `.${part}` : part;
+    }
+    return out || '(root)';
+}
+/**
+ * A value did not have the shape its contract requires. Thrown where a Zod
+ * schema's `.parse()` used to throw a `ZodError`; `issues` keeps that error's
+ * issue shape (`code`, `path`, `message`), holding the first issue Zod reports.
+ */
+class ContractCheckError extends Error {
+    constructor(issue, context) {
+        const where = formatCheckPath(issue.path);
+        super(`${context ? `${context}: ` : ''}${where}: ${issue.message}`);
+        this.name = 'ContractCheckError';
+        this.issues = [issue];
+        Object.setPrototypeOf(this, ContractCheckError.prototype);
+    }
+}
+exports.ContractCheckError = ContractCheckError;
+/** The checked value, or `null` — the twin of `safeParseContract`. */
+function checkContract(check, input) {
+    const checked = check(input, []);
+    return checked.ok ? checked.value : null;
+}
+/** The checked value; throws {@link ContractCheckError} — the twin of a schema's `.parse()`. */
+function parseContract(check, input, context) {
+    const checked = check(input, []);
+    if (!checked.ok)
+        throw new ContractCheckError(checked.issue, context);
+    return checked.value;
+}
+/**
+ * `exact<DeviceSessionState>()(check)` compiles only when `check` produces
+ * exactly `DeviceSessionState` — every key, every optional mark, every literal
+ * — so a contract type that changes without its check is a type error here.
+ */
+function exact() {
+    return (check) => check;
+}

package/dist/cjs/client/deviceBoot.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * The first-party login result check, without Zod. Schemas: `../deviceBoot.ts`.
+ *
+ * Part of `@oxy.so/contracts/client`: never import `zod` here (see `./check.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginResultCheck = void 0;
+const check_1 = require("./check");
+const securityAlert = (0, check_1.object)({
+    message: (0, check_1.string)(),
+    anomalies: (0, check_1.array)((0, check_1.object)({ type: (0, check_1.string)(), reason: (0, check_1.string)(), details: (0, check_1.optional)((0, check_1.string)()) })),
+});
+exports.loginResultCheck = (0, check_1.exact)()((0, check_1.object)({
+    sessionId: (0, check_1.string)(),
+    deviceId: (0, check_1.string)(),
+    expiresAt: (0, check_1.string)(),
+    accessToken: (0, check_1.optional)((0, check_1.string)()),
+    deviceSecret: (0, check_1.optional)((0, check_1.string)()),
+    securityAlert: (0, check_1.optional)(securityAlert),
+    user: (0, check_1.object)({ id: (0, check_1.string)(), username: (0, check_1.optional)((0, check_1.string)()), avatar: (0, check_1.optional)((0, check_1.string)()) }),
+}));

package/dist/cjs/client/deviceDirectory.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Device-directory checks, without Zod. Schemas: `../deviceDirectory.ts`.
+ *
+ * Part of `@oxy.so/contracts/client`: never import `zod` here (see `./check.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceDirectorySyncCheck = exports.deviceActivateResponseCheck = exports.deviceDirectoryCheck = void 0;
+const accountGraph_1 = require("./accountGraph");
+const check_1 = require("./check");
+const deviceSession_1 = require("./deviceSession");
+const userResponse_1 = require("./userResponse");
+const DEVICE_CONTEXT_RELATIONSHIPS = ['self', 'owner', 'member'];
+const profile = (0, check_1.object)({
+    id: (0, check_1.string)((0, check_1.minLength)(1)),
+    username: (0, check_1.string)(),
+    name: (0, check_1.optional)(userResponse_1.userNameCheck),
+    avatar: (0, check_1.optional)((0, check_1.nullable)((0, check_1.string)())),
+    color: (0, check_1.optional)((0, check_1.nullable)((0, check_1.string)())),
+});
+const accountContext = (0, check_1.object)({
+    id: (0, check_1.string)((0, check_1.minLength)(1)),
+    accountId: (0, check_1.string)((0, check_1.minLength)(1)),
+    kind: (0, check_1.oneOf)(accountGraph_1.ACCOUNT_KINDS),
+    relationship: (0, check_1.oneOf)(DEVICE_CONTEXT_RELATIONSHIPS),
+    account: profile,
+    onDevice: check_1.boolean,
+    available: check_1.boolean,
+    active: check_1.boolean,
+    lastUsedAt: (0, check_1.nullable)((0, check_1.number)()),
+});
+const principal = (0, check_1.object)({
+    id: (0, check_1.string)((0, check_1.minLength)(1)),
+    userId: (0, check_1.string)((0, check_1.minLength)(1)),
+    authuser: (0, check_1.number)(check_1.int, check_1.nonnegative),
+    user: profile,
+    contexts: (0, check_1.array)(accountContext),
+});
+exports.deviceDirectoryCheck = (0, check_1.exact)()((0, check_1.object)({
+    deviceId: (0, check_1.string)((0, check_1.minLength)(1)),
+    revision: (0, check_1.number)(check_1.int, check_1.nonnegative),
+    activeContextId: (0, check_1.nullable)((0, check_1.string)()),
+    principals: (0, check_1.array)(principal),
+    updatedAt: (0, check_1.number)(),
+}));
+exports.deviceActivateResponseCheck = (0, check_1.exact)()((0, check_1.object)({ directory: exports.deviceDirectoryCheck, activeToken: (0, check_1.nullable)(deviceSession_1.activeTokenCheck) }));
+exports.deviceDirectorySyncCheck = (0, check_1.exact)()((0, check_1.object)({
+    directory: exports.deviceDirectoryCheck,
+    state: deviceSession_1.deviceSessionStateCheck,
+    activeToken: (0, check_1.nullable)(deviceSession_1.activeTokenCheck),
+}));

package/dist/cjs/client/deviceSession.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Device-session checks, without Zod. Schemas: `../deviceSession.ts`.
+ *
+ * Part of `@oxy.so/contracts/client`: never import `zod` here (see `./check.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceJoinCodeResponseCheck = exports.deviceJoinResponseCheck = exports.deviceRegisterResponseCheck = exports.deviceBackgroundCredentialResponseCheck = exports.sessionAccountsChangedEventCheck = exports.deviceTokenMintResponseCheck = exports.deviceSessionSyncCheck = exports.activeTokenCheck = exports.deviceSessionStateCheck = exports.SESSION_ACCOUNTS_CHANGED_EVENT = void 0;
+const check_1 = require("./check");
+/* -------------------------------------------------------------------------- */
+/*  Instant cross-app session sync (token-free socket signal)                 */
+/* -------------------------------------------------------------------------- */
+/**
+ * Name of the token-free Socket.IO event emitted to room `user:<userId>` on
+ * every DeviceSession mutation that changes what is signed in for that user.
+ *
+ * This is a pure SIGNAL — it carries NO access token, NO deviceSecret and NO
+ * account bodies. A client that receives it re-fetches its authenticated
+ * session/account state (`GET /session/device/state`, `GET /accounts`). Unlike
+ * `session_state` (scoped to `device:<deviceId>`, i.e. a single origin), this
+ * reaches ALL of a user's connected sockets across their devices/origins so
+ * every Oxy app reflects an add / switch / signout instantly.
+ */
+exports.SESSION_ACCOUNTS_CHANGED_EVENT = 'session_accounts_changed';
+/* -------------------------------------------------------------------------- */
+/*  Response checks                                                           */
+/* -------------------------------------------------------------------------- */
+const SESSION_ACCOUNTS_CHANGED_REASONS = ['login', 'add', 'switch', 'signout', 'revoke'];
+const sessionAccount = (0, check_1.object)({
+    accountId: (0, check_1.string)(),
+    sessionId: (0, check_1.string)(),
+    authuser: (0, check_1.number)(check_1.int, check_1.nonnegative),
+    operatedByUserId: (0, check_1.optional)((0, check_1.string)()),
+});
+exports.deviceSessionStateCheck = (0, check_1.exact)()((0, check_1.object)({
+    deviceId: (0, check_1.string)(),
+    accounts: (0, check_1.array)(sessionAccount),
+    activeAccountId: (0, check_1.nullable)((0, check_1.string)()),
+    revision: (0, check_1.number)(check_1.int, check_1.nonnegative),
+    updatedAt: (0, check_1.number)(),
+}));
+exports.activeTokenCheck = (0, check_1.exact)()((0, check_1.object)({ accessToken: (0, check_1.string)(), expiresAt: (0, check_1.string)() }));
+exports.deviceSessionSyncCheck = (0, check_1.exact)()((0, check_1.object)({ state: exports.deviceSessionStateCheck, activeToken: (0, check_1.nullable)(exports.activeTokenCheck) }));
+exports.deviceTokenMintResponseCheck = (0, check_1.exact)()((0, check_1.object)({
+    accessToken: (0, check_1.string)(),
+    expiresAt: (0, check_1.string)(),
+    nextDeviceSecret: (0, check_1.string)(),
+    state: exports.deviceSessionStateCheck,
+}));
+exports.sessionAccountsChangedEventCheck = (0, check_1.exact)()((0, check_1.object)({
+    userId: (0, check_1.string)(),
+    revision: (0, check_1.number)(check_1.int, check_1.nonnegative),
+    reason: (0, check_1.oneOf)(SESSION_ACCOUNTS_CHANGED_REASONS),
+}));
+exports.deviceBackgroundCredentialResponseCheck = (0, check_1.exact)()((0, check_1.object)({
+    deviceId: (0, check_1.string)((0, check_1.minLength)(1)),
+    secret: (0, check_1.string)((0, check_1.minLength)(1)),
+    accountId: (0, check_1.string)((0, check_1.minLength)(1)),
+    expiresAt: (0, check_1.string)(),
+}));
+exports.deviceRegisterResponseCheck = (0, check_1.exact)()((0, check_1.object)({ deviceId: (0, check_1.string)((0, check_1.minLength)(1)), deviceSecret: (0, check_1.string)((0, check_1.minLength)(1)) }));
+exports.deviceJoinResponseCheck = (0, check_1.exact)()(exports.deviceRegisterResponseCheck);
+exports.deviceJoinCodeResponseCheck = (0, check_1.exact)()((0, check_1.object)({ code: (0, check_1.string)((0, check_1.minLength)(1)), expiresIn: (0, check_1.number)(check_1.int, check_1.positive) }));

package/dist/cjs/client/externalIdentity.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * The external-identity reference check, without Zod. Schemas: `../externalIdentity.ts`.
+ *
+ * Part of `@oxy.so/contracts/client`: never import `zod` here (see `./check.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.externalIdentityReferenceCheck = void 0;
+const check_1 = require("./check");
+const required = (0, check_1.string)((0, check_1.minLength)(1));
+/** One Oxy-proven network alias of a profile — the twin of `externalIdentityReferenceSchema`. */
+exports.externalIdentityReferenceCheck = (0, check_1.exact)()((0, check_1.object)({
+    canonicalAcct: required,
+    network: required,
+    protocol: (0, check_1.oneOf)(['activitypub', 'atproto', 'instagram-graph']),
+    actorUri: required,
+    transportAcct: required,
+    sourceUserId: required,
+}));

package/dist/cjs/client/identity.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * The signed-record envelope check, without Zod. Schemas: `../identity.ts`.
+ *
+ * Part of `@oxy.so/contracts/client`: never import `zod` here (see `./check.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signedRecordEnvelopeCheck = void 0;
+const check_1 = require("./check");
+const CHAIN_FIELDS = ['seq', 'prev', 'collection', 'rkey'];
+/** The twin of `signedRecordEnvelopeSchema`: v2 requires the chain fields, v1 forbids them. */
+exports.signedRecordEnvelopeCheck = (0, check_1.exact)()((0, check_1.refineAt)((0, check_1.object)({
+    version: (0, check_1.union)((0, check_1.literal)(1), (0, check_1.literal)(2)),
+    type: (0, check_1.string)((0, check_1.minLength)(1)),
+    subject: (0, check_1.string)(),
+    issuer: (0, check_1.string)(),
+    record: check_1.unknownRecord,
+    issuedAt: (0, check_1.number)(),
+    seq: (0, check_1.optional)((0, check_1.number)(check_1.int, check_1.nonnegative)),
+    prev: (0, check_1.optional)((0, check_1.nullable)((0, check_1.string)())),
+    collection: (0, check_1.optional)((0, check_1.string)((0, check_1.minLength)(1))),
+    rkey: (0, check_1.optional)((0, check_1.string)((0, check_1.minLength)(1))),
+    publicKey: (0, check_1.string)(),
+    alg: (0, check_1.literal)('ES256K-DER-SHA256'),
+    signature: (0, check_1.string)(),
+}), (env) => {
+    if (env.version === 2) {
+        if (typeof env.seq !== 'number')
+            return { path: ['seq'], message: 'v2 envelope requires `seq`' };
+        if (env.prev === undefined) {
+            return { path: ['prev'], message: 'v2 envelope requires `prev` (use `null` at genesis)' };
+        }
+        if (typeof env.collection !== 'string') {
+            return { path: ['collection'], message: 'v2 envelope requires `collection`' };
+        }
+        if (typeof env.rkey !== 'string') {
+            return { path: ['rkey'], message: 'v2 envelope requires `rkey`' };
+        }
+        return undefined;
+    }
+    const carried = CHAIN_FIELDS.find((field) => env[field] !== undefined);
+    return carried
+        ? { path: [carried], message: `v1 envelope must not carry \`${carried}\`` }
+        : undefined;
+}));