@scalebun-release/react-native 2.5.0

package/src/vendor/protocol/internal/validation.ts

@@ -0,0 +1,497 @@
+/**
+ * Internal validation — a tiny, dependency-free, Metro-friendly validator.
+ *
+ * This is NOT a general-purpose schema library. It implements only the exact
+ * subset of the Zod API surface that the ScaleBun SDK protocol + config schemas
+ * use, so we can drop the runtime `zod` dependency entirely.
+ *
+ * Supported builders : string, number, boolean, literal, enum, object, array,
+ *                       record, unknown/any, discriminatedUnion.
+ * Supported modifiers : .optional(), .nullable(), .default(), .refine(),
+ *                       string .min()/.url(), number .int()/.min()/.max(),
+ *                       object .extend().
+ * Result API          : .parse() (throws), .safeParse() (no-throw), with an
+ *                       error exposing `.issues` and `.format()`.
+ *
+ * The public `z` object below is a drop-in for the small slice of the Zod `z`
+ * builder the schemas relied on. Use `Infer<typeof Schema>` in place of
+ * `z.infer<...>`.
+ *
+ * Builder functions return narrow public INTERFACES (no private fields, no
+ * unique-symbol types) so TypeScript declaration emit stays clean for the
+ * exported schema constants.
+ */
+
+// ─── Result + issue shapes ───────────────────────────────────────────────────
+
+export type ValidationIssue = {
+    path: Array<string | number>;
+    message: string;
+};
+
+/** Recursive shape returned by ValidationError.format(), mirroring Zod's. */
+export type FormattedError = {
+    _errors: string[];
+    [key: string]: FormattedError | string[];
+};
+
+export class ValidationError extends Error {
+    readonly issues: ValidationIssue[];
+
+    constructor(issues: ValidationIssue[]) {
+        super(issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`).join('; '));
+        this.name = 'ValidationError';
+        this.issues = issues;
+    }
+
+    /** Nested error object keyed by path, matching Zod's `error.format()`. */
+    format(): FormattedError {
+        const root: FormattedError = { _errors: [] };
+        for (const issue of this.issues) {
+            if (issue.path.length === 0) {
+                root._errors.push(issue.message);
+                continue;
+            }
+            let node = root;
+            for (let i = 0; i < issue.path.length; i++) {
+                const key = String(issue.path[i]);
+                const existing = node[key];
+                let child: FormattedError;
+                if (existing && !Array.isArray(existing)) {
+                    child = existing;
+                } else {
+                    child = { _errors: [] };
+                    node[key] = child;
+                }
+                if (i === issue.path.length - 1) {
+                    child._errors.push(issue.message);
+                }
+                node = child;
+            }
+        }
+        return root;
+    }
+}
+
+export type SafeParseResult<T> =
+    | { success: true; data: T }
+    | { success: false; error: ValidationError };
+
+// ─── Internal parse plumbing ────────────────────────────────────────────────
+
+export type ParseCtx = { issues: ValidationIssue[] };
+
+/** Sentinel returned by `_parse` on failure. A plain branded object (not a
+ *  unique symbol) so it serializes cleanly in `.d.ts` output. */
+export type Fail = { readonly __validationFail: true };
+export const FAIL: Fail = { __validationFail: true };
+
+function addIssue(ctx: ParseCtx, path: Array<string | number>, message: string): Fail {
+    ctx.issues.push({ path, message });
+    return FAIL;
+}
+
+// ─── Public schema interfaces ────────────────────────────────────────────────
+
+export interface Schema<T> {
+    /** Phantom — carries the inferred output type for `Infer<>`. */
+    readonly _output: T;
+    /** @internal — parse impl shared across schemas. */
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T | Fail;
+    parse(input: unknown): T;
+    safeParse(input: unknown): SafeParseResult<T>;
+    optional(): Schema<T | undefined>;
+    nullable(): Schema<T | null>;
+    /** Accepts a Partial because object defaults like `.default({})` rely on the
+     *  inner schema filling missing fields at parse time (Zod input semantics). */
+    default(value: Partial<T> | (() => T)): Schema<T>;
+    refine(check: (value: T) => boolean, message: string | { message: string }): Schema<T>;
+}
+
+export interface StringSchemaType extends Schema<string> {
+    min(n: number, message?: string): StringSchemaType;
+    url(message?: string): StringSchemaType;
+}
+
+export interface NumberSchemaType extends Schema<number> {
+    int(): NumberSchemaType;
+    min(n: number): NumberSchemaType;
+    max(n: number): NumberSchemaType;
+}
+
+export type Shape = Record<string, Schema<unknown>>;
+
+export interface ObjectSchemaType<S extends Shape> extends Schema<ObjectOutput<S>> {
+    readonly shape: S;
+    extend<E extends Shape>(extension: E): ObjectSchemaType<Omit<S, keyof E> & E>;
+}
+
+// ─── Object output type inference ─────────────────────────────────────────────
+
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [K in keyof T]: T[K] }>;
+type OptionalKeys<S extends Shape> = {
+    [K in keyof S]: undefined extends Infer<S[K]> ? K : never;
+}[keyof S];
+type RequiredKeys<S extends Shape> = Exclude<keyof S, OptionalKeys<S>>;
+export type ObjectOutput<S extends Shape> = Flatten<
+    { [K in RequiredKeys<S>]: Infer<S[K]> } & { [K in OptionalKeys<S>]?: Infer<S[K]> }
+>;
+
+/** Output type of a schema — drop-in for `z.infer<typeof Schema>`. */
+export type Infer<S> = S extends Schema<infer T> ? T : never;
+
+// ─── Base class ────────────────────────────────────────────────────────────────
+
+abstract class BaseSchema<T> implements Schema<T> {
+    readonly _output!: T;
+
+    abstract _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T | Fail;
+
+    safeParse(input: unknown): SafeParseResult<T> {
+        const ctx: ParseCtx = { issues: [] };
+        const result = this._parse(input, [], ctx);
+        if (result === FAIL || ctx.issues.length > 0) {
+            return { success: false, error: new ValidationError(ctx.issues) };
+        }
+        return { success: true, data: result as T };
+    }
+
+    parse(input: unknown): T {
+        const r = this.safeParse(input);
+        if (!r.success) throw r.error;
+        return r.data;
+    }
+
+    optional(): Schema<T | undefined> {
+        return new OptionalSchema<T>(this);
+    }
+
+    nullable(): Schema<T | null> {
+        return new NullableSchema<T>(this);
+    }
+
+    default(value: Partial<T> | (() => T)): Schema<T> {
+        return new DefaultSchema<T>(this, value);
+    }
+
+    refine(check: (value: T) => boolean, message: string | { message: string }): Schema<T> {
+        return new RefineSchema<T>(this, check, typeof message === 'string' ? message : message.message);
+    }
+}
+
+// ─── string ───────────────────────────────────────────────────────────────────
+
+class StringSchema extends BaseSchema<string> implements StringSchemaType {
+    private _min?: number;
+    private _minMsg?: string;
+    private _url = false;
+    private _urlMsg?: string;
+
+    min(n: number, message?: string): StringSchemaType {
+        this._min = n;
+        this._minMsg = message;
+        return this;
+    }
+
+    url(message?: string): StringSchemaType {
+        this._url = true;
+        this._urlMsg = message;
+        return this;
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): string | Fail {
+        if (typeof input !== 'string') {
+            return addIssue(ctx, path, `Expected string, received ${typeofName(input)}`);
+        }
+        if (this._min !== undefined && input.length < this._min) {
+            return addIssue(ctx, path, this._minMsg ?? `String must contain at least ${this._min} character(s)`);
+        }
+        if (this._url && !isValidUrl(input)) {
+            return addIssue(ctx, path, this._urlMsg ?? 'Invalid url');
+        }
+        return input;
+    }
+}
+
+// ─── number ───────────────────────────────────────────────────────────────────
+
+class NumberSchema extends BaseSchema<number> implements NumberSchemaType {
+    private _int = false;
+    private _min?: number;
+    private _max?: number;
+
+    int(): NumberSchemaType {
+        this._int = true;
+        return this;
+    }
+
+    min(n: number): NumberSchemaType {
+        this._min = n;
+        return this;
+    }
+
+    max(n: number): NumberSchemaType {
+        this._max = n;
+        return this;
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): number | Fail {
+        if (typeof input !== 'number' || Number.isNaN(input)) {
+            return addIssue(ctx, path, `Expected number, received ${typeofName(input)}`);
+        }
+        if (this._int && !Number.isInteger(input)) {
+            return addIssue(ctx, path, 'Expected integer, received float');
+        }
+        if (this._min !== undefined && input < this._min) {
+            return addIssue(ctx, path, `Number must be greater than or equal to ${this._min}`);
+        }
+        if (this._max !== undefined && input > this._max) {
+            return addIssue(ctx, path, `Number must be less than or equal to ${this._max}`);
+        }
+        return input;
+    }
+}
+
+// ─── boolean ───────────────────────────────────────────────────────────────────
+
+class BooleanSchema extends BaseSchema<boolean> {
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): boolean | Fail {
+        if (typeof input !== 'boolean') {
+            return addIssue(ctx, path, `Expected boolean, received ${typeofName(input)}`);
+        }
+        return input;
+    }
+}
+
+// ─── literal ───────────────────────────────────────────────────────────────────
+
+class LiteralSchema<V extends string | number | boolean> extends BaseSchema<V> {
+    constructor(readonly value: V) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): V | Fail {
+        if (input !== this.value) {
+            return addIssue(ctx, path, `Invalid literal value, expected ${JSON.stringify(this.value)}`);
+        }
+        return input as V;
+    }
+}
+
+// ─── enum ───────────────────────────────────────────────────────────────────────
+
+class EnumSchema<T extends readonly [string, ...string[]]> extends BaseSchema<T[number]> {
+    constructor(readonly values: T) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T[number] | Fail {
+        if (typeof input !== 'string' || !this.values.includes(input)) {
+            return addIssue(ctx, path, `Invalid enum value. Expected ${this.values.map((v) => `'${v}'`).join(' | ')}`);
+        }
+        return input as T[number];
+    }
+}
+
+// ─── array ───────────────────────────────────────────────────────────────────────
+
+class ArraySchema<E extends Schema<unknown>> extends BaseSchema<Array<Infer<E>>> {
+    constructor(readonly element: E) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): Array<Infer<E>> | Fail {
+        if (!Array.isArray(input)) {
+            return addIssue(ctx, path, `Expected array, received ${typeofName(input)}`);
+        }
+        const out: Array<Infer<E>> = [];
+        let ok = true;
+        for (let i = 0; i < input.length; i++) {
+            const r = this.element._parse(input[i], [...path, i], ctx);
+            if (r === FAIL) ok = false;
+            else out.push(r as Infer<E>);
+        }
+        return ok ? out : FAIL;
+    }
+}
+
+// ─── record ───────────────────────────────────────────────────────────────────────
+
+class RecordSchema<V extends Schema<unknown>> extends BaseSchema<Record<string, Infer<V>>> {
+    constructor(readonly value: V) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): Record<string, Infer<V>> | Fail {
+        if (!isPlainObject(input)) {
+            return addIssue(ctx, path, `Expected object, received ${typeofName(input)}`);
+        }
+        const out: Record<string, Infer<V>> = {};
+        let ok = true;
+        for (const key of Object.keys(input)) {
+            const r = this.value._parse(input[key], [...path, key], ctx);
+            if (r === FAIL) ok = false;
+            else out[key] = r as Infer<V>;
+        }
+        return ok ? out : FAIL;
+    }
+}
+
+// ─── unknown / any ─────────────────────────────────────────────────────────────
+
+class UnknownSchema extends BaseSchema<unknown> {
+    _parse(input: unknown): unknown {
+        return input;
+    }
+}
+
+// ─── object ───────────────────────────────────────────────────────────────────────
+
+class ObjectSchema<S extends Shape> extends BaseSchema<ObjectOutput<S>> implements ObjectSchemaType<S> {
+    constructor(readonly shape: S) {
+        super();
+    }
+
+    extend<E extends Shape>(extension: E): ObjectSchemaType<Omit<S, keyof E> & E> {
+        return new ObjectSchema({ ...this.shape, ...extension }) as unknown as ObjectSchemaType<Omit<S, keyof E> & E>;
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): ObjectOutput<S> | Fail {
+        if (!isPlainObject(input)) {
+            return addIssue(ctx, path, `Expected object, received ${typeofName(input)}`);
+        }
+        const out: Record<string, unknown> = {};
+        let ok = true;
+        for (const key of Object.keys(this.shape)) {
+            const r = this.shape[key]._parse(input[key], [...path, key], ctx);
+            if (r === FAIL) ok = false;
+            else if (r !== undefined || key in input) out[key] = r;
+        }
+        // Unknown keys are stripped (Zod's default `.strip()` behaviour).
+        return ok ? (out as ObjectOutput<S>) : FAIL;
+    }
+}
+
+// ─── discriminated union ────────────────────────────────────────────────────────
+
+class DiscriminatedUnionSchema<Opts extends Schema<unknown>[]> extends BaseSchema<Infer<Opts[number]>> {
+    constructor(readonly key: string, readonly options: Opts) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): Infer<Opts[number]> | Fail {
+        if (!isPlainObject(input)) {
+            return addIssue(ctx, path, `Expected object, received ${typeofName(input)}`);
+        }
+        const discriminator = input[this.key];
+        const match = this.options.find((opt) => {
+            const field = (opt as unknown as ObjectSchema<Shape>).shape?.[this.key];
+            return field instanceof LiteralSchema && field.value === discriminator;
+        });
+        if (!match) {
+            return addIssue(ctx, [...path, this.key], `Invalid discriminator value ${JSON.stringify(discriminator)}`);
+        }
+        const r = match._parse(input, path, ctx);
+        return r === FAIL ? FAIL : (r as Infer<Opts[number]>);
+    }
+}
+
+// ─── modifiers ───────────────────────────────────────────────────────────────────
+
+class OptionalSchema<T> extends BaseSchema<T | undefined> {
+    constructor(readonly inner: Schema<T>) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T | undefined | Fail {
+        if (input === undefined) return undefined;
+        return this.inner._parse(input, path, ctx);
+    }
+}
+
+class NullableSchema<T> extends BaseSchema<T | null> {
+    constructor(readonly inner: Schema<T>) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T | null | Fail {
+        if (input === null) return null;
+        return this.inner._parse(input, path, ctx);
+    }
+}
+
+class DefaultSchema<T> extends BaseSchema<T> {
+    constructor(readonly inner: Schema<T>, readonly defaultValue: Partial<T> | (() => T)) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T | Fail {
+        const value =
+            input === undefined
+                ? typeof this.defaultValue === 'function'
+                    ? (this.defaultValue as () => T)()
+                    : this.defaultValue
+                : input;
+        return this.inner._parse(value, path, ctx);
+    }
+}
+
+class RefineSchema<T> extends BaseSchema<T> {
+    constructor(readonly inner: Schema<T>, readonly check: (value: T) => boolean, readonly message: string) {
+        super();
+    }
+
+    _parse(input: unknown, path: Array<string | number>, ctx: ParseCtx): T | Fail {
+        const r = this.inner._parse(input, path, ctx);
+        if (r === FAIL) return FAIL;
+        if (!this.check(r as T)) {
+            return addIssue(ctx, path, this.message);
+        }
+        return r as T;
+    }
+}
+
+// ─── helpers ───────────────────────────────────────────────────────────────────
+
+function typeofName(value: unknown): string {
+    if (value === null) return 'null';
+    if (Array.isArray(value)) return 'array';
+    return typeof value;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isValidUrl(value: string): boolean {
+    const URLCtor = (globalThis as { URL?: new (input: string) => unknown }).URL;
+    try {
+        if (typeof URLCtor !== 'undefined') {
+            // eslint-disable-next-line no-new
+            new URLCtor(value);
+            return /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+        }
+    } catch {
+        return false;
+    }
+    return /^[a-z][a-z0-9+.-]*:\/\/[^\s]+$/i.test(value);
+}
+
+// ─── public `z` builder (Zod-subset drop-in) ─────────────────────────────────────
+
+export const z = {
+    string: (): StringSchemaType => new StringSchema(),
+    number: (): NumberSchemaType => new NumberSchema(),
+    boolean: (): Schema<boolean> => new BooleanSchema(),
+    literal: <V extends string | number | boolean>(value: V): Schema<V> => new LiteralSchema<V>(value),
+    enum: <U extends string, T extends readonly [U, ...U[]]>(values: T): Schema<T[number]> =>
+        new EnumSchema<T>(values),
+    object: <S extends Shape>(shape: S): ObjectSchemaType<S> => new ObjectSchema<S>(shape),
+    array: <E extends Schema<unknown>>(element: E): Schema<Array<Infer<E>>> => new ArraySchema<E>(element),
+    record: <V extends Schema<unknown>>(value: V): Schema<Record<string, Infer<V>>> => new RecordSchema<V>(value),
+    unknown: (): Schema<unknown> => new UnknownSchema(),
+    any: (): Schema<any> => new UnknownSchema() as Schema<any>,
+    discriminatedUnion: <Opts extends Schema<unknown>[]>(key: string, options: Opts): Schema<Infer<Opts[number]>> =>
+        new DiscriminatedUnionSchema<Opts>(key, options),
+};

package/src/vendor/sdk-contracts/bridge.ts

@@ -0,0 +1,162 @@
+/**
+ * @scalebun/sdk-contracts — Bridge Protocol Types
+ *
+ * Pure type definitions for the debug protocol messages.
+ * Zod schemas, parsers, serializers, and runtime constants
+ * (PROTOCOL_VERSION) stay in scalebun-sdk/src/debug/protocol.ts.
+ */
+
+// ─── Base Fields ────────────────────────────────────────────────────────────
+
+export interface BaseMessage {
+    protocolVersion: number;
+    deviceId: string;
+    sessionId: string;
+    timestamp: number;
+    sequence: number;
+}
+
+// ─── Message Types ──────────────────────────────────────────────────────────
+
+export interface HelloMessage extends BaseMessage {
+    type: 'hello';
+    payload: {
+        appName?: string;
+        appVersion?: string;
+        bundleId?: string;
+        platform?: 'ios' | 'android' | 'web';
+        osVersion?: string;
+        deviceModel?: string;
+        sdkVersion?: string;
+        buildType?: 'debug' | 'release';
+        capabilities?: string[];
+        token?: string;
+    };
+}
+
+export type EventCategory =
+    | 'log'
+    | 'network'
+    | 'navigation'
+    | 'lifecycle'
+    | 'crash'
+    | 'breadcrumb'
+    | 'replay'
+    | 'journey'
+    | 'session'
+    | 'performance'
+    | 'profiler'
+    | 'export'
+    | 'custom';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export interface EventMessage extends BaseMessage {
+    type: 'event';
+    payload: {
+        id: string;
+        category: EventCategory;
+        name: string;
+        data?: Record<string, unknown>;
+        level?: LogLevel;
+        tags?: string[];
+    };
+}
+
+export interface MetricMessage extends BaseMessage {
+    type: 'metric';
+    payload: {
+        name: string;
+        value: number;
+        unit?: string;
+        tags?: Record<string, string>;
+    };
+}
+
+export type CommandName =
+    | 'ping'
+    | 'setLogLevel'
+    | 'clearQueue'
+    | 'triggerFlush'
+    | 'addBreadcrumb'
+    | 'startReplay'
+    | 'stopReplay'
+    | 'snapshot'
+    | 'startSession'
+    | 'stopSession'
+    | 'captureFrame'
+    | 'perfCaptureScreen'
+    | 'journeyRecordToggle'
+    | 'journeyCaptureStep'
+    | 'journeySave'
+    | 'journeyRun'
+    | 'journeyStopRun'
+    | 'reloadApp'
+    | 'exportReportResult';
+
+export interface CommandMessage extends BaseMessage {
+    type: 'command';
+    payload: {
+        commandId: string;
+        name: CommandName;
+        args?: Record<string, unknown>;
+    };
+}
+
+export interface CommandResultMessage extends BaseMessage {
+    type: 'command_result';
+    payload: {
+        commandId: string;
+        success: boolean;
+        data?: Record<string, unknown>;
+        error?: string;
+    };
+}
+
+export interface ErrorMessage extends BaseMessage {
+    type: 'error';
+    payload: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+
+// ─── Control Messages ───────────────────────────────────────────────────────
+
+export interface PingMessage {
+    type: 'scalebun:ping';
+    deviceId: string;
+    timestamp: number;
+}
+
+export interface PongMessage {
+    type: 'scalebun:pong';
+    timestamp: number;
+    echoTimestamp: number;
+}
+
+export interface AckMessage {
+    type: 'scalebun:ack';
+    serverVersion: string;
+    heartbeatIntervalMs: number;
+    timestamp: number;
+}
+
+// ─── Union Types ────────────────────────────────────────────────────────────
+
+export type DebugMessage =
+    | HelloMessage
+    | EventMessage
+    | MetricMessage
+    | CommandMessage
+    | CommandResultMessage
+    | ErrorMessage;
+
+export type AnyScaleBunMessage = DebugMessage | PingMessage | PongMessage | AckMessage;
+
+// ─── Parse Result ───────────────────────────────────────────────────────────
+
+export type ParseResult<T> =
+    | { success: true; data: T }
+    | { success: false; error: string; raw: unknown };