@vercel/board 0.16.0 → 0.18.0

package/dist/reducer-CYPHsSmd-BQIfozGi.d.mts

@@ -0,0 +1,170 @@
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/reducer-CYPHsSmd.d.ts
+//#region src/standard-schema.d.ts
+/**
+ * The Standard Schema interface, vendored per the spec's guidance
+ * (https://standardschema.dev — the interface is designed to be copied
+ * into libraries rather than depended on). Types only; nothing here
+ * exists at runtime.
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+//#region src/contract.d.ts
+/** The event vocabulary shape: event name → payload schema. */
+type EventDefs = Record<string, StandardSchemaV1>;
+/** The presence vocabulary shape: field name → value schema. */
+type PresenceDefs = Record<string, StandardSchemaV1>;
+/** One event of a contract, narrowed to type `K`. */
+type ContractEvent<D extends EventDefs, K extends keyof D & string = keyof D & string> = { [T in keyof D & string]: {
+  id: string;
+  type: T;
+  payload: StandardSchemaV1.InferOutput<D[T]>;
+  index: number;
+  sessionId: string;
+  createdAt: Date;
+}; }[K];
+/** Input to `append`/`push`, typed against the contract's schemas. */
+type AppendInput<D extends EventDefs> = { [T in keyof D & string]: {
+  type: T;
+  payload: StandardSchemaV1.InferInput<D[T]>;
+  id?: string;
+}; }[keyof D & string];
+type EventBatchFactory<D extends EventDefs> = <const E extends readonly AppendInput<D>[]>(...events: E) => E;
+/**
+ * One presence update: a participant's changed fields (`null` marks a
+ * cleared one), stamped with the sender's stream frontier (`seen`).
+ * This is what `stream({ presence: true })` interleaves with events.
+ */
+type PresencePatch<P extends PresenceDefs = PresenceDefs> = {
+  participant: string;
+  values: { [F in keyof P & string]?: StandardSchemaV1.InferOutput<P[F]> | null; };
+  seen: number;
+  at: Date;
+};
+/**
+ * The replicated ephemeral map: participant → field → latest value,
+ * last-writer-wins per field. Never stored in the log; how long a
+ * value stays painted is view logic, decided at render time against
+ * `at`.
+ */
+type PresenceMap<P extends PresenceDefs = PresenceDefs> = {
+  [participant: string]: { [F in keyof P & string]?: {
+    value: StandardSchemaV1.InferOutput<P[F]>;
+    seen: number;
+    at: Date;
+  }; };
+};
+/**
+ * The one item a presence stream yields before live patches: the
+ * current pruned map, per-field stamps exact. Discriminate
+ * structurally (`'snapshot' in item`).
+ */
+type PresenceSnapshot<P extends PresenceDefs = PresenceDefs> = {
+  snapshot: PresenceMap<P>;
+};
+/**
+ * Intersect into a surface type to add `Members` only when the
+ * contract declares presence fields — on presence-less contracts the
+ * members do not exist, a type error rather than a runtime throw.
+ */
+type WithPresence<P extends PresenceDefs, Members> = keyof P extends never ? unknown : Members;
+type Contract<D extends EventDefs = EventDefs, P extends PresenceDefs = Record<never, never>, R = RegisteredReducer<D, P> | undefined> = {
+  /** Identity — prefixes storage keys and queue messages. */
+  readonly name: string;
+  /** The vocabulary. */
+  readonly events: Readonly<D>;
+  /** The presence vocabulary — empty unless declared. */
+  readonly presence: Readonly<P>;
+  /** Preserve literal types for a consumer-returned event batch. */
+  readonly batch: EventBatchFactory<D>;
+  readonly reducer: R;
+};
+/**
+ * A pure fold over a session's events — `(state, event) => state` —
+ * published inline in a contract or built with `reducer(options).fold(fn)`.
+ *
+ * The name is the reducer's identity. Cached folds (server snapshots,
+ * the browser cache) are keyed by it, which makes it the invalidation
+ * knob too: changed the fold's logic? Change the name. Snapshots under
+ * the old name are ignored and the next read refolds from raw events.
+ * See docs/contract/02-state.mdx.
+ */
+type Reducer<D extends EventDefs = EventDefs, S = unknown, P extends PresenceDefs = Record<never, never>> = {
+  /** Identity and cache key. Rename when the fold's logic changes. */
+  readonly name: string;
+  /** The contract's vocabulary — types every event in the fold. */
+  readonly events: Readonly<D>;
+  /**
+   * The contract's presence vocabulary — carried because the reducer
+   * is the client's typed handle on the contract. The fold never sees
+   * presence.
+   */
+  readonly presence: Readonly<P>;
+  readonly fold: (state: S, event: ContractEvent<D>) => S;
+  readonly initialState: S;
+  /**
+   * When present: `initialState` was validated against it at
+   * definition, and any cached fold a2 rehydrates (server snapshots,
+   * the browser cache) is checked against it — failing snapshots are
+   * discarded and refolded, catching shape drift a stale name can't.
+   */
+  readonly stateSchema: StandardSchemaV1<unknown, S> | undefined;
+};
+type RegisteredReducer<D extends EventDefs, P extends PresenceDefs> = Omit<Reducer<D, unknown, P>, "fold"> & {
+  readonly fold: (state: never, event: never) => unknown;
+};
+//#endregion
+export { PresenceDefs as a, PresenceSnapshot as c, WithPresence as d, EventDefs as i, Reducer as l, Contract as n, PresenceMap as o, ContractEvent as r, PresencePatch as s, AppendInput as t, RegisteredReducer as u };

package/dist/reducer-CjmvZSAb-D_OSISmj.mjs

@@ -0,0 +1,74 @@
+import { a as isSessionCleared } from "./session-clear-wHd5GCpZ-BnKSxReK.mjs";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/reducer-CjmvZSAb.js
+/**
+* Run a Standard Schema validator, requiring a synchronous result.
+* Validators must be synchronous (specs/a2-api.md §1) — an async one is
+* a definition bug, rejected at definition time where possible and here
+* as a backstop. `what` names the schema in error messages, e.g.
+* "event 'created'" or "the stateSchema".
+*/
+function validateSync(schema, value, what) {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise) throw new TypeError(`the schema for ${what} is asynchronous — a2 schemas must validate synchronously`);
+	return result;
+}
+/**
+* Probe a schema to reject always-async validators early. The probe
+* value is deliberately garbage — we only care whether the result is a
+* Promise, not whether it passes.
+*/
+function assertSyncSchema(schema, what) {
+	const probe = Symbol("a2.schema-probe");
+	const result = schema["~standard"].validate(probe);
+	if (result instanceof Promise) {
+		result.catch(() => {});
+		throw new TypeError(`the schema for ${what} is asynchronous — a2 schemas must validate synchronously`);
+	}
+}
+/**
+* A fresh copy of a reducer's seed, so a fold that mutates in place
+* cannot corrupt the shared `initialState`. Non-cloneable seeds
+* (functions, class instances, proxies) fall back to the original.
+*/
+function cloneInitial(initial) {
+	try {
+		return structuredClone(initial);
+	} catch {
+		return initial;
+	}
+}
+const markerFolds = /* @__PURE__ */ new WeakSet();
+/** One fold step; a clear marker resets to the seed on server and client alike. */
+function foldEvent(source, state, event) {
+	if (!isSessionCleared(event)) return source.fold(state, event);
+	return markerFolds.has(source.fold) ? source.fold(state, event) : cloneInitial(source.initialState);
+}
+/** Internal — shared validation for inline and standalone reducer definitions. */
+function makeReducerBuilder(events, presence, options) {
+	const { name } = options;
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("reducer name must be a non-empty string — it identifies the reducer and keys cached snapshots");
+	let initialState = options.initialState;
+	if (options.stateSchema) {
+		const result = validateSync(options.stateSchema, options.initialState, "the stateSchema");
+		if (result.issues) throw new TypeError(`reducer initialState does not match its stateSchema: ${result.issues.map((issue) => issue.message).join("; ")}`);
+		initialState = result.value;
+		const restored = validateSync(options.stateSchema, initialState, "the stateSchema");
+		if (restored.issues || JSON.stringify(restored.value) !== JSON.stringify(initialState)) throw new TypeError("stateSchema must accept and preserve its own output so snapshots can be restored");
+	}
+	return { fold(fold) {
+		if (typeof fold !== "function") throw new TypeError("reducer fold must be a function");
+		return {
+			name,
+			events,
+			presence,
+			fold,
+			initialState,
+			stateSchema: options.stateSchema
+		};
+	} };
+}
+function reducer(options) {
+	return makeReducerBuilder(options.contract.events, options.contract.presence, options);
+}
+//#endregion
+export { reducer as a, makeReducerBuilder as i, cloneInitial as n, validateSync as o, foldEvent as r, assertSyncSchema as t };