@platforma-open/milaboratories.sequence-embeddings 1.4.0 → 1.4.2

package/dist/AGENTS.d.ts

@@ -1,4 +1,5 @@
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/author_marker.d.ts
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/author_marker.d.ts
 //#region src/author_marker.d.ts
 /** Structure to help resolve conflicts if multiple participants writes to
  * the same state */
@@ -8,10 +9,11 @@ interface AuthorMarker {
   authorId: string;
   /** Sequential version of the state local to the author */
   localVersion: number;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/typeAliases.d.cts
 type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type Scalars = Primitive | Primitive[];
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.d.cts
 declare namespace util {
@@ -24,8 +26,8 @@ declare namespace util {
   export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
   export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
   export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };
-  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k };
+  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined; };
+  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
   export const getValidEnumValues: (obj: any) => any[];
   export const objectValues: (obj: any) => any[];
   export const objectKeys: ObjectConstructor["keys"];
@@ -39,16 +41,16 @@ declare namespace util {
   export {};
 }
 declare namespace objectUtil {
-  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k] } & V;
-  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never }[keyof T];
-  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k }[keyof T];
-  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K] } & { [K in optionalKeys<T>]?: T[K] } & { [k in keyof T]?: unknown };
+  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k]; } & V;
+  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never; }[keyof T];
+  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k; }[keyof T];
+  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K]; } & { [K in optionalKeys<T>]?: T[K]; } & { [k in keyof T]?: unknown; };
   export type identity<T> = T;
-  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
-  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k }[keyof T];
-  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never }>;
+  export type flatten<T> = identity<{ [k in keyof T]: T[k]; }>;
+  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k; }[keyof T];
+  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never; }>;
   export const mergeShapes: <U, T>(first: U, second: T) => T & U;
-  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] };
+  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K]; } & { [K in keyof B]: B[K]; };
   export {};
 }
 declare const ZodParsedType: {
@@ -74,12 +76,14 @@ declare const ZodParsedType: {
   set: "set";
 };
 type ZodParsedType = keyof typeof ZodParsedType;
+declare const getParsedType: (data: any) => ZodParsedType;
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.d.cts
 type allKeys<T> = T extends any ? keyof T : never;
+type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
 type typeToFlattenedError<T, U = string> = {
   formErrors: U[];
-  fieldErrors: { [P in allKeys<T>]?: U[] };
+  fieldErrors: { [P in allKeys<T>]?: U[]; };
 };
 declare const ZodIssueCode: {
   invalid_type: "invalid_type";
@@ -184,17 +188,22 @@ interface ZodCustomIssue extends ZodIssueBase {
     [k: string]: any;
   };
 }
+type DenormalizedError = {
+  [k: string]: DenormalizedError | string[];
+};
 type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
 type ZodIssue = ZodIssueOptionalMessage & {
   fatal?: boolean | undefined;
   message: string;
 };
-type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]> } : T extends any[] ? {
+declare const quotelessJson: (obj: any) => string;
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]>; } : T extends any[] ? {
   [k: number]: ZodFormattedError<T[number]>;
-} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]> } : unknown;
+} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]>; } : unknown;
 type ZodFormattedError<T, U = string> = {
   _errors: U[];
 } & recursiveZodFormattedError<NonNullable<T>>;
+type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
 declare class ZodError<T = any> extends Error {
   issues: ZodIssue[];
   get errors(): ZodIssue[];
@@ -225,7 +234,20 @@ type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
   message: string;
 };
 //#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.d.cts
+declare const errorMap: ZodErrorMap;
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/errors.d.cts
+declare function setErrorMap(map: ZodErrorMap): void;
+declare function getErrorMap(): ZodErrorMap;
+//#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.d.cts
+declare const makeIssue: (params: {
+  data: any;
+  path: (string | number)[];
+  errorMaps: ZodErrorMap[];
+  issueData: IssueData;
+}) => ZodIssue;
 type ParseParams = {
   path: (string | number)[];
   errorMap: ZodErrorMap;
@@ -233,6 +255,7 @@ type ParseParams = {
 };
 type ParsePathComponent = string | number;
 type ParsePath = ParsePathComponent[];
+declare const EMPTY_PATH: ParsePath;
 interface ParseContext {
   readonly common: {
     readonly issues: ZodIssue[];
@@ -250,6 +273,11 @@ type ParseInput = {
   path: (string | number)[];
   parent: ParseContext;
 };
+declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+type ObjectPair = {
+  key: SyncParseReturnType<any>;
+  value: SyncParseReturnType<any>;
+};
 declare class ParseStatus {
   value: "aborted" | "dirty" | "valid";
   dirty(): void;
@@ -265,6 +293,10 @@ declare class ParseStatus {
     alwaysSet?: boolean;
   }[]): SyncParseReturnType;
 }
+interface ParseResult {
+  status: "aborted" | "dirty" | "valid";
+  data: any;
+}
 type INVALID = {
   status: "aborted";
 };
@@ -282,6 +314,10 @@ declare const OK: <T>(value: T) => OK<T>;
 type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
 type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
 type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
+declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/enumUtil.d.cts
 declare namespace enumUtil {
@@ -306,7 +342,7 @@ declare namespace errorUtil {
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/partialUtil.d.cts
 declare namespace partialUtil {
-  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>; }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never; } extends (infer PI) ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
 }
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/standard-schema.d.cts
@@ -437,6 +473,10 @@ type RawCreateParams = {
   message?: string | undefined;
   description?: string | undefined;
 } | undefined;
+type ProcessedCreateParams = {
+  errorMap?: ZodErrorMap | undefined;
+  description?: string | undefined;
+};
 type SafeParseSuccess<Output> = {
   success: true;
   data: Output;
@@ -605,6 +645,11 @@ interface ZodStringDef extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodString;
   coerce: boolean;
 }
+declare function datetimeRegex(args: {
+  precision?: number | null;
+  offset?: boolean;
+  local?: boolean;
+}): RegExp;
 declare class ZodString extends ZodType<string, ZodStringDef, string> {
   _parse(input: ParseInput): ParseReturnType<string>;
   protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
@@ -735,6 +780,135 @@ declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
   get isInt(): boolean;
   get isFinite(): boolean;
 }
+type ZodBigIntCheck = {
+  kind: "min";
+  value: bigint;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: bigint;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "multipleOf";
+  value: bigint;
+  message?: string | undefined;
+};
+interface ZodBigIntDef extends ZodTypeDef {
+  checks: ZodBigIntCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodBigInt;
+  coerce: boolean;
+}
+declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
+  _parse(input: ParseInput): ParseReturnType<bigint>;
+  _getInvalidInput(input: ParseInput): INVALID;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodBigInt;
+  gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+  gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+  lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
+  _addCheck(check: ZodBigIntCheck): ZodBigInt;
+  positive(message?: errorUtil.ErrMessage): ZodBigInt;
+  negative(message?: errorUtil.ErrMessage): ZodBigInt;
+  nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
+  nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
+  multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  get minValue(): bigint | null;
+  get maxValue(): bigint | null;
+}
+interface ZodBooleanDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodBoolean;
+  coerce: boolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
+  _parse(input: ParseInput): ParseReturnType<boolean>;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodBoolean;
+}
+type ZodDateCheck = {
+  kind: "min";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  message?: string | undefined;
+};
+interface ZodDateDef extends ZodTypeDef {
+  checks: ZodDateCheck[];
+  coerce: boolean;
+  typeName: ZodFirstPartyTypeKind.ZodDate;
+}
+declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  _addCheck(check: ZodDateCheck): ZodDate;
+  min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+  max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+  get minDate(): Date | null;
+  get maxDate(): Date | null;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodDate;
+}
+interface ZodSymbolDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodSymbol;
+}
+declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodSymbol;
+}
+interface ZodUndefinedDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUndefined;
+}
+declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  params?: RawCreateParams;
+  static create: (params?: RawCreateParams) => ZodUndefined;
+}
+interface ZodNullDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNull;
+}
+declare class ZodNull extends ZodType<null, ZodNullDef, null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodNull;
+}
+interface ZodAnyDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodAny;
+}
+declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
+  _any: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodAny;
+}
+interface ZodUnknownDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUnknown;
+}
+declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
+  _unknown: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodUnknown;
+}
+interface ZodNeverDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNever;
+}
+declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodNever;
+}
+interface ZodVoidDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodVoid;
+}
+declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodVoid;
+}
 interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   type: T;
   typeName: ZodFirstPartyTypeKind.ZodArray;
@@ -762,6 +936,7 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
   nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
   static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
+type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
 type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodObject;
@@ -769,10 +944,11 @@ interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends
   catchall: Catchall;
   unknownKeys: UnknownKeys;
 }
+type mergeTypes<A, B> = { [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never; };
 type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"] };
+type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"]; };
 type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"] }>;
+type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"]; }>;
 type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
   [k: string]: T["_output"];
 };
@@ -783,6 +959,8 @@ type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
   [k: string]: unknown;
 } : unknown;
 type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+type noUnrecognized<Obj extends object, Shape extends object> = { [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never; };
 declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
   private _cached;
   _getCached(): {
@@ -810,18 +988,18 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
    * upgrade if you are experiencing issues.
    */
   merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
-  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall>;
+  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema; }, UnknownKeys, Catchall>;
   catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-  pick<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-  omit<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+  pick<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+  omit<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
   /**
    * @deprecated
    */
   deepPartial(): partialUtil.DeepPartial<this>;
-  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]> }, UnknownKeys, Catchall>;
-  partial<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
-  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]> }, UnknownKeys, Catchall>;
-  required<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
+  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]>; }, UnknownKeys, Catchall>;
+  partial<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k]; }>, UnknownKeys, Catchall>;
+  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]>; }, UnknownKeys, Catchall>;
+  required<Mask extends util.Exactly<{ [k in keyof T]?: true; }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k]; }>, UnknownKeys, Catchall>;
   keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
   static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
   static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
@@ -838,6 +1016,28 @@ declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_ou
   get options(): T;
   static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
+type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{ [key in Discriminator]: ZodTypeAny; } & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
+  discriminator: Discriminator;
+  options: Options;
+  optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
+  typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+}
+declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get discriminator(): Discriminator;
+  get options(): Options;
+  get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;
+  /**
+   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+   * have a different value for each object in the union.
+   * @param discriminator the name of the discriminator property
+   * @param types an array of object schemas
+   * @param params
+   */
+  static create<Discriminator extends string, Types extends readonly [ZodDiscriminatedUnionOption<Discriminator>, ...ZodDiscriminatedUnionOption<Discriminator>[]]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
+}
 interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   left: T;
   right: U;
@@ -849,21 +1049,98 @@ declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extend
 }
 type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 type AssertArray<T> = T extends any[] ? T : never;
-type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never }>;
+type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never; }>;
 type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never }>;
+type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never; }>;
 type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
 interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
   items: T;
   rest: Rest;
   typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
+type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAny | null>;
 declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   get items(): T;
   rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
   static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
+interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+type KeySchema = ZodType<string | number | symbol, any, any>;
+type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): Value;
+  static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
+  static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
+}
+interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodMap;
+}
+declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+}
+interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  typeName: ZodFirstPartyTypeKind.ZodSet;
+  minSize: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  maxSize: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+}
+declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  min(minSize: number, message?: errorUtil.ErrMessage): this;
+  max(maxSize: number, message?: errorUtil.ErrMessage): this;
+  size(size: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
+  static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+}
+interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  args: Args;
+  returns: Returns;
+  typeName: ZodFirstPartyTypeKind.ZodFunction;
+}
+type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  parameters(): Args;
+  returnType(): Returns;
+  args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
+  returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
+  implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+  strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
+  validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+  static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
+  static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
+  static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
+  static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
+}
+interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  getter: () => T;
+  typeName: ZodFirstPartyTypeKind.ZodLazy;
+}
+declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
+  get schema(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+}
 interface ZodLiteralDef<T = any> extends ZodTypeDef {
   value: T;
   typeName: ZodFirstPartyTypeKind.ZodLiteral;
@@ -873,13 +1150,15 @@ declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
   get value(): T;
   static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 }
+type ArrayKeys = keyof any[];
+type Indices<T> = Exclude<keyof T, ArrayKeys>;
 type EnumValues<T extends string = string> = readonly [T, ...T[]];
-type Values<T extends EnumValues> = { [k in T[number]]: k };
+type Values<T extends EnumValues> = { [k in T[number]]: k; };
 interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
   values: T;
   typeName: ZodFirstPartyTypeKind.ZodEnum;
 }
-type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+type Writeable<T> = { -readonly [P in keyof T]: T[P]; };
 type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
 type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
@@ -895,6 +1174,20 @@ declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number]
   exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
   static create: typeof createZodEnum;
 }
+interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
+}
+type EnumLike = {
+  [k: string]: string | number;
+  [nu: number]: string;
+};
+declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
+  _cache: Set<T[keyof T]> | undefined;
+  _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+  get enum(): T;
+  static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+}
 interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   type: T;
   typeName: ZodFirstPartyTypeKind.ZodPromise;
@@ -904,6 +1197,8 @@ declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_outpu
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
+type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
 type RefinementEffect<T> = {
   type: "refinement";
   refinement: (arg: T, ctx: RefinementCtx) => any;
@@ -933,6 +1228,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   innerType: T;
   typeName: ZodFirstPartyTypeKind.ZodOptional;
 }
+type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   unwrap(): T;
@@ -942,6 +1238,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   innerType: T;
   typeName: ZodFirstPartyTypeKind.ZodNullable;
 }
+type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   unwrap(): T;
@@ -974,13 +1271,20 @@ declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCa
     catch: Inner["_output"] | (() => Inner["_output"]);
   }) => ZodCatch<Inner>;
 }
+interface ZodNaNDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNaN;
+}
+declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create: (params?: RawCreateParams) => ZodNaN;
+}
 interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
   type: T;
   typeName: ZodFirstPartyTypeKind.ZodBranded;
 }
 declare const BRAND: unique symbol;
 type BRAND<T extends string | number | symbol> = {
-  [BRAND]: { [k in T]: true };
+  [BRAND]: { [k in T]: true; };
 };
 declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
   _parse(input: ParseInput): ParseReturnType<any>;
@@ -1008,6 +1312,24 @@ declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["
   static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
   unwrap(): T;
 }
+type CustomParams = CustomErrorParams & {
+  fatal?: boolean;
+};
+declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams),
+/**
+ * @deprecated
+ *
+ * Pass `fatal` into the params object instead:
+ *
+ * ```ts
+ * z.string().custom((val) => val.length > 5, { fatal: false })
+ * ```
+ *
+ */
+fatal?: boolean): ZodType<T, ZodTypeDef, T>;
+declare const late: {
+  object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+};
 declare enum ZodFirstPartyTypeKind {
   ZodString = "ZodString",
   ZodNumber = "ZodNumber",
@@ -1046,6 +1368,69 @@ declare enum ZodFirstPartyTypeKind {
   ZodPipeline = "ZodPipeline",
   ZodReadonly = "ZodReadonly"
 }
+type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
+declare abstract class Class {
+  constructor(..._: any[]);
+}
+declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
+declare const stringType: (params?: RawCreateParams & {
+  coerce?: true;
+}) => ZodString;
+declare const numberType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
+declare const bigIntType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodBigInt;
+declare const booleanType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodBoolean;
+declare const dateType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodDate;
+declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
+declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
+declare const nullType: (params?: RawCreateParams) => ZodNull;
+declare const anyType: (params?: RawCreateParams) => ZodAny;
+declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
+declare const neverType: (params?: RawCreateParams) => ZodNever;
+declare const voidType: (params?: RawCreateParams) => ZodVoid;
+declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
+declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+declare const recordType: typeof ZodRecord.create;
+declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+declare const functionType: typeof ZodFunction.create;
+declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+declare const enumType: typeof createZodEnum;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+declare const pipelineType: typeof ZodPipeline.create;
+declare const ostring: () => ZodOptional<ZodString>;
+declare const onumber: () => ZodOptional<ZodNumber>;
+declare const oboolean: () => ZodOptional<ZodBoolean>;
+declare const coerce: {
+  string: (typeof ZodString)["create"];
+  number: (typeof ZodNumber)["create"];
+  boolean: (typeof ZodBoolean)["create"];
+  bigint: (typeof ZodBigInt)["create"];
+  date: (typeof ZodDate)["create"];
+};
+declare const NEVER: never;
+declare namespace external_d_exports {
+  export { AnyZodObject, AnyZodTuple, ArrayCardinality, ArrayKeys, AssertArray, AsyncParseReturnType, BRAND, CatchallInput, CatchallOutput, CustomErrorParams, DIRTY, DenormalizedError, EMPTY_PATH, Effect, EnumLike, EnumValues, ErrorMapCtx, FilterEnum, INVALID, Indices, InnerTypeOfFunction, InputTypeOfTuple, InputTypeOfTupleWithRest, IpVersion, IssueData, KeySchema, NEVER, OK, ObjectPair, OuterTypeOfFunction, OutputTypeOfTuple, OutputTypeOfTupleWithRest, ParseContext, ParseInput, ParseParams, ParsePath, ParsePathComponent, ParseResult, ParseReturnType, ParseStatus, PassthroughType, PreprocessEffect, Primitive, ProcessedCreateParams, RawCreateParams, RecordType, Refinement, RefinementCtx, RefinementEffect, SafeParseError, SafeParseReturnType, SafeParseSuccess, Scalars, ZodType as Schema, SomeZodObject, StringValidation, SuperRefinement, SyncParseReturnType, TransformEffect, TypeOf, UnknownKeysParam, Values, Writeable, ZodAny, ZodAnyDef, ZodArray, ZodArrayDef, ZodBigInt, ZodBigIntCheck, ZodBigIntDef, ZodBoolean, ZodBooleanDef, ZodBranded, ZodBrandedDef, ZodCatch, ZodCatchDef, ZodCustomIssue, ZodDate, ZodDateCheck, ZodDateDef, ZodDefault, ZodDefaultDef, ZodDiscriminatedUnion, ZodDiscriminatedUnionDef, ZodDiscriminatedUnionOption, ZodEffects, ZodEffectsDef, ZodEnum, ZodEnumDef, ZodError, ZodErrorMap, ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind, ZodFormattedError, ZodFunction, ZodFunctionDef, ZodIntersection, ZodIntersectionDef, ZodInvalidArgumentsIssue, ZodInvalidDateIssue, ZodInvalidEnumValueIssue, ZodInvalidIntersectionTypesIssue, ZodInvalidLiteralIssue, ZodInvalidReturnTypeIssue, ZodInvalidStringIssue, ZodInvalidTypeIssue, ZodInvalidUnionDiscriminatorIssue, ZodInvalidUnionIssue, ZodIssue, ZodIssueBase, ZodIssueCode, ZodIssueOptionalMessage, ZodLazy, ZodLazyDef, ZodLiteral, ZodLiteralDef, ZodMap, ZodMapDef, ZodNaN, ZodNaNDef, ZodNativeEnum, ZodNativeEnumDef, ZodNever, ZodNeverDef, ZodNonEmptyArray, ZodNotFiniteIssue, ZodNotMultipleOfIssue, ZodNull, ZodNullDef, ZodNullable, ZodNullableDef, ZodNullableType, ZodNumber, ZodNumberCheck, ZodNumberDef, ZodObject, ZodObjectDef, ZodOptional, ZodOptionalDef, ZodOptionalType, ZodParsedType, ZodPipeline, ZodPipelineDef, ZodPromise, ZodPromiseDef, ZodRawShape, ZodReadonly, ZodReadonlyDef, ZodRecord, ZodRecordDef, ZodType as ZodSchema, ZodSet, ZodSetDef, ZodString, ZodStringCheck, ZodStringDef, ZodSymbol, ZodSymbolDef, ZodTooBigIssue, ZodTooSmallIssue, ZodEffects as ZodTransformer, ZodTuple, ZodTupleDef, ZodTupleItems, ZodType, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUndefinedDef, ZodUnion, ZodUnionDef, ZodUnionOptions, ZodUnknown, ZodUnknownDef, ZodUnrecognizedKeysIssue, ZodVoid, ZodVoidDef, addIssueToContext, anyType as any, arrayType as array, arrayOutputType, baseObjectInputType, baseObjectOutputType, bigIntType as bigint, booleanType as boolean, coerce, custom, dateType as date, datetimeRegex, errorMap as defaultErrorMap, deoptional, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getErrorMap, getParsedType, TypeOf as infer, inferFlattenedErrors, inferFormattedError, input, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, mergeTypes, nanType as nan, nativeEnumType as nativeEnum, neverType as never, noUnrecognized, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectInputType, objectOutputType, objectUtil, oboolean, onumber, optionalType as optional, ostring, output, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, typeToFlattenedError, typecast, undefinedType as undefined, unionType as union, unknownType as unknown, util, voidType as void };
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-error-like@1.12.10/node_modules/@milaboratories/pl-error-like/dist/error_like_shape.d.ts
 //#region src/error_like_shape.d.ts
@@ -1098,9 +1483,8 @@ type StandardErrorLike = TypeOf<typeof BaseStandardErrorLike> & {
 declare const StandardErrorLike: ZodType<StandardErrorLike>;
 declare const ErrorLike: ZodUnion<[ZodType<StandardErrorLike, ZodTypeDef, StandardErrorLike>, ZodType<PlErrorLike, ZodTypeDef, PlErrorLike>]>;
 type ErrorLike = TypeOf<typeof ErrorLike>;
-/** Converts everything into ErrorLike. */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/common_types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/common_types.d.ts
 type OutputWithStatus<T> = {
   ok: true;
   value: T;
@@ -1113,7 +1497,7 @@ type OutputWithStatus<T> = {
 /** Base type for block outputs */
 type BlockOutputsBase = Record<string, OutputWithStatus<unknown>>;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/navigation.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/navigation.d.ts
 /**
  * Part of the block state, representing current navigation information
  * (i.e. currently selected section)
@@ -1122,14 +1506,14 @@ type NavigationState<Href extends `/${string}` = `/${string}`> = {
   readonly href: Href;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/json.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/json.d.ts
 //#region src/json.d.ts
 type JsonPrimitive = string | number | boolean | null;
 type JsonValue = JsonPrimitive | JsonValue[] | {
   [key: string]: JsonValue;
 };
 type NotAssignableToJson = bigint | symbol | Function;
-type JsonCompatible<T> = unknown extends T ? unknown : [T] extends [JsonValue] ? T : [T] extends [NotAssignableToJson] ? never : { [P in keyof T]: [Exclude<T[P], undefined>] extends [JsonValue] ? T[P] : [Exclude<T[P], undefined>] extends [NotAssignableToJson] ? never : JsonCompatible<T[P]> };
+type JsonCompatible<T> = unknown extends T ? unknown : [T] extends [JsonValue] ? T : [T] extends [NotAssignableToJson] ? never : { [P in keyof T]: [Exclude<T[P], undefined>] extends [JsonValue] ? T[P] : [Exclude<T[P], undefined>] extends [NotAssignableToJson] ? never : JsonCompatible<T[P]>; };
 type StringifiedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
   __json_stringified: T;
 };
@@ -1137,7 +1521,7 @@ type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never :
   __json_canonicalized: T;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/block_state.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/block_state.d.ts
 //#region src/block_state.d.ts
 /**
  * @template Args    sets type of block arguments passed to the workflow
@@ -1148,7 +1532,7 @@ type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never :
  * @template Href    typed href to represent navigation state
  */
 type BlockState<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = {
-  /** Block arguments passed to the workflow */args: Args;
+  /** Block arguments passed to the workflow */ args: Args;
   /** UI State persisted in the block state but not passed to the backend
    * template */
   ui: UiState; /** Outputs rendered with block config */
@@ -1157,18 +1541,18 @@ type BlockState<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsB
   readonly author: AuthorMarker | undefined;
 };
 type BlockStateV3<_Data = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> = {
-  /** Block storage persisted in the block state */blockStorage: StringifiedJson; /** Outputs rendered with block config */
+  /** Block storage persisted in the block state */ blockStorage: StringifiedJson; /** Outputs rendered with block config */
   outputs: Outputs; /** Current navigation state */
   navigationState: NavigationState<Href>;
   readonly author: AuthorMarker | undefined;
-}; //#endregion
+};
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/branding.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/branding.d.ts
 //#region src/branding.d.ts
-type Brand<B, K extends string = "__pl_model_brand__"> = { [key in K]: B };
-type Branded$1<T, B, K extends string = "__pl_model_brand__"> = T & Brand<B, K>; //#endregion
+type Brand<B, K extends string = "__pl_model_brand__"> = { [key in K]: B; };
+type Branded$1<T, B, K extends string = "__pl_model_brand__"> = T & Brand<B, K>;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/dialog/index.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/dialog/index.d.ts
 //#region src/dialog/index.d.ts
 /**
  * File filter passed to the native save dialog. Matches Electron's
@@ -1199,9 +1583,9 @@ interface ShowSaveDialogResult {
  */
 interface DialogService {
   showSaveDialog(options: ShowSaveDialogOptions): Promise<ShowSaveDialogResult>;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/pool_entry.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/pool_entry.d.ts
 //#region src/pool_entry.d.ts
 interface PoolEntry<K extends string = string, R extends {} = {}> extends Disposable {
   /** Resource key, calculated using provided `calculateParamsKey` function */
@@ -1215,12 +1599,8 @@ interface PoolEntry<K extends string = string, R extends {} = {}> extends Dispos
    */
   readonly unref: () => void;
 }
-/**
- * Wraps a PoolEntry for use with `using`. Auto-calls `unref()` at end of scope
- * unless `keep()` is called to transfer ownership to the caller.
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.d.ts
 //#region src/drivers/pframe/table_common.d.ts
 type PTableColumnSpecAxis = {
   type: "axis";
@@ -1251,7 +1631,7 @@ type PTableColumnIdColumn = {
 /** Unified PTable column identifier */
 type PTableColumnId = PTableColumnIdAxis | PTableColumnIdColumn;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_types.d.ts
 //#region src/drivers/pframe/data_types.d.ts
 type PVectorDataInt = Int32Array;
 type PVectorDataLong = BigInt64Array;
@@ -1261,7 +1641,7 @@ type PVectorDataString = (null | string)[];
 type PVectorDataBytes = (null | Uint8Array)[];
 type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int ? PVectorDataInt : DataType extends typeof ValueType.Long ? PVectorDataLong : DataType extends typeof ValueType.Float ? PVectorDataFloat : DataType extends typeof ValueType.Double ? PVectorDataDouble : DataType extends typeof ValueType.String ? PVectorDataString : DataType extends typeof ValueType.Bytes ? PVectorDataBytes : never;
 type PTableVectorTyped<DataType extends ValueType> = {
-  /** Stored data type */readonly type: DataType; /** Values for present positions */
+  /** Stored data type */ readonly type: DataType; /** Values for present positions */
   readonly data: PVectorDataTyped<DataType>;
   /**
    * Encoded bit array marking some elements of this vector as NA,
@@ -1275,22 +1655,33 @@ type PTableVectorTyped<DataType extends ValueType> = {
 type PTableVector = PTableVectorTyped<ValueType>;
 /** Used in requests to partially retrieve table's data */
 type TableRange = {
-  /** Index of the first record to retrieve */readonly offset: number; /** Block length */
+  /** Index of the first record to retrieve */ readonly offset: number; /** Block length */
   readonly length: number;
 };
 /** Unified information about table shape */
 type PTableShape = {
-  /** Number of unified table columns, including all axes and PColumn values */columns: number; /** Number of rows */
+  /** Number of unified table columns, including all axes and PColumn values */ columns: number; /** Number of rows */
   rows: number;
 };
 /** Supported formats for PTable file download. */
 type PTableDownloadFormat = "csv" | "tsv";
-/** Compression applied to the written file. */
 /** Options for downloading PTable data to a file. */
 interface WritePTableToFsOptions {
   path: string;
   format: PTableDownloadFormat;
   columnIndices: number[];
+  /**
+   * Optional header names aligned 1:1 with {@link columnIndices}. When provided,
+   * each is written verbatim — letting callers supply disambiguated labels the
+   * spec's intrinsic `pl7.app/label` may not carry. When omitted (or an
+   * individual entry is empty), the header falls back to the column's
+   * spec-derived label.
+   *
+   * Additive on purpose: the UI (ui-vue) and the desktop-app runtime version
+   * independently, so a newer UI must not send a shape an older runtime cannot
+   * read. Older runtimes ignore this field and use {@link columnIndices} alone.
+   */
+  headerNames?: string[];
   range?: TableRange;
   chunkSize?: number;
   includeHeader?: boolean;
@@ -1307,11 +1698,6 @@ interface WritePTableToFsResult {
   rowsWritten: number;
   bytesWritten: number;
 }
-/**
- * Maximum number of data rows allowed per sheet in an `xlsx` export, kept below
- * Excel's hard limit of 1,048,576. The driver rejects oversized `xlsx` exports
- * (see {@link PFrameDriver.exportPTable}); UIs use it to gate the `xlsx` option.
- */
 /** Options for {@link PFrameDriver.exportPTable}. */
 interface ExportPTableOptions {
   /** Destination file path; its extension selects the output format
@@ -1320,9 +1706,21 @@ interface ExportPTableOptions {
   /** Unified indices of the columns to export, in output order
    * (axes first, then data columns). */
   columnIndices: number[];
-} //#endregion
+  /**
+   * Optional header names aligned 1:1 with {@link columnIndices}. When provided,
+   * each is written verbatim — letting callers supply disambiguated labels the
+   * spec's intrinsic `pl7.app/label` may not carry. When omitted (or an
+   * individual entry is empty), the header falls back to the column's
+   * spec-derived label.
+   *
+   * Additive on purpose: the UI (ui-vue) and the desktop-app runtime version
+   * independently, so a newer UI must not send a shape an older runtime cannot
+   * read. Older runtimes ignore this field and use {@link columnIndices} alone.
+   */
+  headerNames?: string[];
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.d.ts
 //#region src/drivers/pframe/data_info.d.ts
 /**
  * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.
@@ -1337,16 +1735,12 @@ type PColumnValue = null | number | string;
  * Can be an array of strings or numbers.
  */
 type PColumnKey = (number | string)[];
-/**
- * Represents a single entry in a PColumn's data structure.
- * Contains a key and a value.
- */
 /**
  * Represents column data stored as a simple JSON structure.
  * Used for small datasets that can be efficiently stored directly in memory.
  */
 type JsonDataInfo = {
-  /** Identifier for this data format ('Json') */type: "Json"; /** Number of axes that make up the complete key (tuple length) */
+  /** Identifier for this data format ('Json') */ type: "Json"; /** Number of axes that make up the complete key (tuple length) */
   keyLength: number;
   /**
    * Key-value pairs where keys are stringified tuples of axis values
@@ -1359,7 +1753,7 @@ type JsonDataInfo = {
  * Used for larger datasets that need to be split into manageable chunks.
  */
 type JsonPartitionedDataInfo<Blob> = {
-  /** Identifier for this data format ('JsonPartitioned') */type: "JsonPartitioned"; /** Number of leading axes used for partitioning */
+  /** Identifier for this data format ('JsonPartitioned') */ type: "JsonPartitioned"; /** Number of leading axes used for partitioning */
   partitionKeyLength: number; /** Map of stringified partition keys to blob references */
   parts: Record<string, Blob>;
 };
@@ -1368,7 +1762,7 @@ type JsonPartitionedDataInfo<Blob> = {
  * Used for efficient storage and retrieval of column data in binary format.
  */
 type BinaryChunk<Blob> = {
-  /** Binary blob containing structured index information */index: Blob; /** Binary blob containing the actual values */
+  /** Binary blob containing structured index information */ index: Blob; /** Binary blob containing the actual values */
   values: Blob;
 };
 /**
@@ -1376,12 +1770,12 @@ type BinaryChunk<Blob> = {
  * Optimized for efficient storage and retrieval of large datasets.
  */
 type BinaryPartitionedDataInfo<Blob> = {
-  /** Identifier for this data format ('BinaryPartitioned') */type: "BinaryPartitioned"; /** Number of leading axes used for partitioning */
+  /** Identifier for this data format ('BinaryPartitioned') */ type: "BinaryPartitioned"; /** Number of leading axes used for partitioning */
   partitionKeyLength: number; /** Map of stringified partition keys to binary chunks */
   parts: Record<string, BinaryChunk<Blob>>;
 };
 type ParquetPartitionedDataInfo<Blob> = {
-  /** Identifier for this data format ('ParquetPartitioned') */type: "ParquetPartitioned"; /** Number of leading axes used for partitioning */
+  /** Identifier for this data format ('ParquetPartitioned') */ type: "ParquetPartitioned"; /** Number of leading axes used for partitioning */
   partitionKeyLength: number; /** Map of stringified partition keys to parquet files */
   parts: Record<string, Blob>;
 };
@@ -1392,12 +1786,6 @@ type ParquetPartitionedDataInfo<Blob> = {
  * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)
  */
 type DataInfo<Blob> = JsonDataInfo | JsonPartitionedDataInfo<Blob> | BinaryPartitionedDataInfo<Blob> | ParquetPartitionedDataInfo<Blob>;
-/**
- * Type guard function that checks if the given value is a valid DataInfo.
- *
- * @param value - The value to check
- * @returns True if the value is a valid DataInfo, false otherwise
- */
 /**
  * Represents a single key-value entry in a column's explicit data structure.
  * Used when directly instantiating PColumns with explicit data.
@@ -1411,11 +1799,8 @@ type PColumnValuesEntry = {
  * Used for lightweight explicit instantiation of PColumns.
  */
 type PColumnValues = PColumnValuesEntry[];
-/**
- * Entry-based representation of JsonDataInfo
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.4/node_modules/@milaboratories/helpers/dist/types/brand.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.5/node_modules/@milaboratories/helpers/dist/types/brand.d.ts
 //#region src/types/brand.d.ts
 /**
  * Phantom-property brand. The key is a plain string literal rather than a
@@ -1437,7 +1822,7 @@ type Branded<T, B> = T & {
   readonly __brand: B;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.d.ts
 //#region src/drivers/pframe/spec/overridden.d.ts
 type SpecOverrides = Pick<PColumnSpec, "domain" | "contextDomain" | "annotations"> & {
   axesSpec?: AxisPatches;
@@ -1454,7 +1839,7 @@ interface ColumnOverriddenKey {
 }
 type ColumnOverriddenId = Branded<CanonicalizedJson<ColumnOverriddenKey>, "ColumnOverriddenId">;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_common.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_common.d.ts
 //#region src/drivers/pframe/query/query_common.d.ts
 /**
  * Structural type information for a single column: the axis value types (in
@@ -1462,7 +1847,7 @@ type ColumnOverriddenId = Branded<CanonicalizedJson<ColumnOverriddenKey>, "Colum
  * `typeSpec` shape carried by the data layer (`{ axes, column }`).
  */
 type ColumnTypeSpec = {
-  /** List of axis value types defining the dimensions of the data */axes: AxisValueType[]; /** The single column value type */
+  /** List of axis value types defining the dimensions of the data */ axes: AxisValueType[]; /** The single column value type */
   column: ColumnValueType;
 };
 /**
@@ -2149,7 +2534,7 @@ interface QuerySliceAxes<Q, A> {
   input: Q;
   /** List of axis filters to apply (at least one required) */
   axisFilters: {
-    /** Axis to filter. `SingleAxisSelector` at the spec layer; axis index at the data layer. */axisSelector: A; /** The constant value to filter the axis to */
+    /** Axis to filter. `SingleAxisSelector` at the spec layer; axis index at the data layer. */ axisSelector: A; /** The constant value to filter the axis to */
     constant: string | number;
   }[];
 }
@@ -2499,9 +2884,9 @@ interface QuerySpecOverride<Q, SO> {
   input: Q;
   /** Spec override patch to overlay on the inner spec. */
   override: SO;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_data.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_data.d.ts
 //#region src/drivers/pframe/query/query_data.d.ts
 /**
  * Column identifier with type specification.
@@ -2510,7 +2895,7 @@ interface QuerySpecOverride<Q, SO> {
  * Used in data layer to carry type information alongside column references.
  */
 type ColumnIdAndTypeSpec = {
-  /** Unique identifier of the column */id: PObjectId; /** Type specification defining the axes and the single column value type */
+  /** Unique identifier of the column */ id: PObjectId; /** Type specification defining the axes and the single column value type */
   spec: ColumnTypeSpec;
 };
 /**
@@ -2548,7 +2933,7 @@ type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
  * - `oneSideAxesIndices` — which axis indices in the joined result to project out
  */
 type DataQueryLinkerJoinLinker = {
-  /** Linker column reference. */column: PObjectId; /** Linker's axes mapped into the joined result. */
+  /** Linker column reference. */ column: PObjectId; /** Linker's axes mapped into the joined result. */
   axesMapping: number[]; /** Axis indices (in the joined result) to project out — the linker's one-side axes. */
   oneSideAxesIndices: number[];
 };
@@ -2579,9 +2964,9 @@ type DataExprAxisRef = ExprAxisRef<number>;
 /** @see ExprColumnRef */
 type DataExprColumnRef = ExprColumnRef<number>;
 type DataQueryExpression = DataExprColumnRef | DataExprAxisRef | ExprConstant | ExprNumericBinary<DataQueryExpression> | ExprNumericComparison<DataQueryExpression> | ExprNumericUnary<DataQueryExpression> | ExprStringEquals<DataQueryExpression> | ExprStringContains<DataQueryExpression> | ExprStringRegex<DataQueryExpression> | ExprStringContainsFuzzy<DataQueryExpression> | ExprIsNull<DataQueryExpression> | ExprFillNull<DataQueryExpression> | ExprLogicalUnary<DataQueryExpression> | ExprLogicalVariadic<DataQueryExpression> | ExprIsIn<DataQueryExpression, string> | ExprIsIn<DataQueryExpression, number> | ExprCast<DataQueryExpression> | ExprConditional<DataQueryExpression> | ExprRanking<DataQueryExpression, number, number>;
-type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>; //#endregion
+type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec_driver.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec_driver.d.ts
 //#region src/drivers/pframe/spec_driver.d.ts
 /** Matches a string value either exactly or by regex pattern */
 type StringMatcher = {
@@ -2692,7 +3077,7 @@ type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilter
  * propagate into the inner query.
  */
 type BuildQueryInput = {
-  /** Shape version marker — bumped only on breaking structural changes. */readonly version: "v1"; /** Terminal column id — the column actually returning data. */
+  /** Shape version marker — bumped only on breaking structural changes. */ readonly version: "v1"; /** Terminal column id — the column actually returning data. */
   readonly column: PObjectId; /** Ordered path from source integration to `column`. Outermost first. */
   readonly path?: DiscoverColumnsStepInfo[]; /** Axis qualifications attached to the resulting join entry. */
   readonly qualifications?: AxisQualification[];
@@ -2794,9 +3179,9 @@ interface PFrameSpecDriver {
     tableSpec: PTableColumnSpec[];
     filters: PTableRecordFilter[];
   }): DataQueryBooleanExpression[];
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.d.ts
 /** Single axis selector */
 interface SingleAxisSelector {
   /** Axis name (required) */
@@ -2817,12 +3202,8 @@ interface AxisQualification {
   /** Additional context domain entries applied to the axis. */
   readonly contextDomain: Record<string, string>;
 }
-/**
- * Reference to an axis by its numerical index within the anchor column's axes array
- * Format: [anchorId, axisIndex]
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_spec.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_spec.d.ts
 //#region src/drivers/pframe/query/query_spec.d.ts
 /**
  * Join entry for spec-layer queries — the base join entry extended with
@@ -2836,7 +3217,7 @@ interface AxisQualification {
  */
 type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
   qualifications?: readonly {
-    /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
+    /** Axis to qualify. */ axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
     contextDomain: Domain;
   }[];
 };
@@ -2889,9 +3270,9 @@ type SpecExprAxisRef = ExprAxisRef<SingleAxisSelector>;
 /** @see ExprColumnRef */
 type SpecExprColumnRef = ExprColumnRef<ColumnUniversalId>;
 type SpecQueryExpression = SpecExprColumnRef | SpecExprAxisRef | ExprConstant | ExprNumericBinary<SpecQueryExpression> | ExprNumericComparison<SpecQueryExpression> | ExprNumericUnary<SpecQueryExpression> | ExprStringEquals<SpecQueryExpression> | ExprStringContains<SpecQueryExpression> | ExprStringRegex<SpecQueryExpression> | ExprStringContainsFuzzy<SpecQueryExpression> | ExprIsNull<SpecQueryExpression> | ExprFillNull<SpecQueryExpression> | ExprLogicalUnary<SpecQueryExpression> | ExprLogicalVariadic<SpecQueryExpression> | ExprIsIn<SpecQueryExpression, string> | ExprIsIn<SpecQueryExpression, number> | ExprCast<SpecQueryExpression> | ExprConditional<SpecQueryExpression> | ExprRanking<SpecQueryExpression, SingleAxisSelector, PObjectId>;
-type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>; //#endregion
+type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.d.ts
 //#region src/drivers/pframe/table_calculate.d.ts
 /** Defines a terminal column node in the join request tree */
 interface ColumnJoinEntry<Col> {
@@ -3145,7 +3526,7 @@ interface PTableRecordSingleValueFilterV2 {
 type PTableRecordFilter = PTableRecordSingleValueFilterV2;
 /** Sorting parameters for a PTable.  */
 type PTableSorting = {
-  /** Unified column identifier */readonly column: PTableColumnId; /** Sorting order */
+  /** Unified column identifier */ readonly column: PTableColumnId; /** Sorting order */
   readonly ascending: boolean; /** Sorting in respect to NA and absent values */
   readonly naAndAbsentAreLeastValues: boolean;
 };
@@ -3167,14 +3548,14 @@ interface PTableDefV2<Col> {
 }
 /** Request to create and retrieve entirety of data of PTable. */
 type CalculateTableDataRequest<Col> = {
-  /** Join tree to populate the PTable */readonly src: JoinEntry<Col>; /** Record filters */
+  /** Join tree to populate the PTable */ readonly src: JoinEntry<Col>; /** Record filters */
   readonly filters: PTableRecordFilter[]; /** Table sorting */
   readonly sorting: PTableSorting[];
 };
 /** Response for {@link CalculateTableDataRequest} */
 type CalculateTableDataResponse = FullPTableColumnData[];
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/ref.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/ref.d.ts
 //#region src/ref.d.ts
 declare const PlRef: ZodReadonly<ZodObject<{
   __isRef: ZodLiteral<true>;
@@ -3193,13 +3574,12 @@ declare const PlRef: ZodReadonly<ZodObject<{
   requireEnrichments?: true | undefined;
 }>>;
 type PlRef = TypeOf<typeof PlRef>;
-/** @deprecated use {@link PlRef} */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/pool/spec.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/pool/spec.d.ts
 //#region src/pool/spec.d.ts
 /** Any object exported into the result pool by the block always have spec attached to it */
 type PObjectSpec = {
-  /** PObject kind discriminator */readonly kind: string; /** Name is common part of PObject identity */
+  /** PObject kind discriminator */ readonly kind: string; /** Name is common part of PObject identity */
   readonly name: string; /** Domain is a set of key-value pairs that can be used to identify the object */
   readonly domain?: Record<string, string>;
   /** Context domain provides additional axis/column identity that is matched
@@ -3230,7 +3610,7 @@ interface PObject<Data> {
   readonly data: Data;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.d.ts
 //#region src/drivers/pframe/spec/spec.d.ts
 declare const ValueType: {
   readonly Int: "Int";
@@ -3271,7 +3651,7 @@ type Domain = Metadata & Partial<{
  * all the axes specified in the column spec.
  */
 type AxisSpec = {
-  /** Type of the axis value. Should not use non-key types like float or double. */readonly type: AxisValueType; /** Name of the axis */
+  /** Type of the axis value. Should not use non-key types like float or double. */ readonly type: AxisValueType; /** Name of the axis */
   readonly name: string;
   /** Adds auxiliary information to the axis name, type and parents to form a
    * unique identifier */
@@ -3302,7 +3682,6 @@ type AxisSpec = {
    */
   readonly parentAxes?: number[];
 };
-/** Parents are specs, not indexes; normalized axis can be used considering its parents independently from column */
 /** Common type representing spec for all the axes in a column */
 type AxesSpec = AxisSpec[];
 /**
@@ -3343,10 +3722,9 @@ type PUniversalColumnSpec = PObjectSpec & {
  * basic tabular data.
  */
 type PDataColumnSpec = PUniversalColumnSpec & {
-  /** Type of column values */readonly valueType: ValueType;
+  /** Type of column values */ readonly valueType: ValueType;
 };
 type PColumnSpec = PDataColumnSpec;
-/** Unique PColumnSpec identifier */
 interface PColumn<Data> extends PObject<Data> {
   /** PColumn spec, allowing it to be found among other PObjects */
   readonly spec: PColumnSpec;
@@ -3359,7 +3737,6 @@ interface PColumnIdAndSpec {
   /** Column spec */
   readonly spec: PColumnSpec;
 }
-/** Get column id and spec from a column */
 interface AxisId {
   /** Type of the axis or column value. For an axis should not use non-key
    * types like float or double. */
@@ -3375,15 +3752,13 @@ interface AxisId {
 }
 /** Array of axis ids */
 type AxesId = AxisId[];
-/** Extracts axis ids from axis spec */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.d.ts
 //#region src/drivers/pframe/spec/filtered_column.d.ts
 /** Value of an axis filter */
 type AxisFilterValue = number | string;
 /** Axis filter by index */
 type AxisFilterByIdx = [number, AxisFilterValue];
-/** Axis filter by name */
 /**
  * `source` is either a leaf {@link PObjectId} or a {@link ColumnDiscoveredId}.
  * Filtered never nests inside Filtered (flat-merge invariant), and Filtered is
@@ -3396,7 +3771,7 @@ interface ColumnFilteredKey {
 }
 type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFilteredId">;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.d.ts
 //#region src/drivers/pframe/spec/ids.d.ts
 /**
  * Per-axis patches keyed by positional index in the base spec's `axesSpec`.
@@ -3408,23 +3783,14 @@ type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFil
  * A patch at index `>= base.axesSpec.length` appends a new axis at that slot.
  */
 type AxisPatches = Record<number, Partial<AxisSpec>>;
-/**
- * Universal column identifier optionally anchored and optionally filtered.
- * @deprecated use {@link ColumnUniversalKey}
- */
 /**
  * Canonically serialized {@link UniversalPColumnId}.
  * @deprecated use {@link ColumnUniversalId}
  */
 type SUniversalPColumnId = ColumnUniversalId;
 type ColumnUniversalId = LocalPObjectId | GlobalPObjectId | ColumnFilteredId | ColumnDiscoveredId | ColumnOverriddenId;
-/**
- * Canonically serializes a column key to a branded string id. Accepts both
- * the new {@link ColumnUniversalKey} and the deprecated {@link UniversalPColumnId}
- * (anchored / old filtered object form).
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.d.ts
 //#region src/drivers/pframe/spec/discovered_column.d.ts
 interface ColumnDiscoveredKey {
   __isDiscovered: true;
@@ -3439,7 +3805,7 @@ type PathItem = {
   column: ColumnUniversalId;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/interfaces.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/interfaces.d.ts
 //#region src/drivers/interfaces.d.ts
 /**
  * Intended to match web.Blob, node.Blob, node-fetch.Blob, etc.
@@ -3462,9 +3828,9 @@ interface FileLike extends BlobLike {
   readonly lastModified: number;
   /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
   readonly name: string;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/blob.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/blob.d.ts
 //#region src/drivers/blob.d.ts
 /** Handle of locally downloaded blob. This handle is issued only after the
  * blob's content is downloaded locally, and ready for quick access. */
@@ -3472,11 +3838,9 @@ type LocalBlobHandle = Branded$1<string, "LocalBlobHandle">;
 /** Handle of remote blob. This handle is issued as soon as the data becomes
  * available on the remote server. */
 type RemoteBlobHandle = Branded$1<string, "RemoteBlobHandle">;
-/** Being configured inside the output structure provides information about
- * blob's content and means to retrieve it when needed. */
 /** Range in bytes, from should be less than to. */
 declare const RangeBytes: ZodObject<{
-  /** Included left border. */from: ZodNumber; /** Excluded right border. */
+  /** Included left border. */ from: ZodNumber; /** Excluded right border. */
   to: ZodNumber;
 }, "strip", ZodTypeAny, {
   from: number;
@@ -3495,11 +3859,8 @@ interface BlobDriver {
    */
   getContent(handle: LocalBlobHandle | RemoteBlobHandle, range?: RangeBytes): Promise<Uint8Array>;
 }
-/**
- * Operational metrics of the blob download driver.
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/log.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/log.d.ts
 //#region src/drivers/log.d.ts
 /** Prefix constants — single source of truth for handle format. */
 declare const LIVE_LOG_PREFIX = "log+live://log/";
@@ -3513,38 +3874,29 @@ type ReadyLogHandle = Branded$1<`${typeof READY_LOG_PREFIX}${string}`, "ReadyLog
 /** Handle of logs. This handle should be passed
  * to the driver for retrieving logs. */
 type AnyLogHandle = LiveLogHandle | ReadyLogHandle;
-/** Type guard to check if a value is any kind of log handle. */
 /** Driver to retrieve logs given log handle */
 interface LogsDriver {
-  lastLines(/** A handle that was issued previously. */
-
-  handle: AnyLogHandle, /** Allows client to limit total data sent from server. */
-
-  lineCount: number,
+  lastLines(
+  /** A handle that was issued previously. */
+  handle: AnyLogHandle /** Allows client to limit total data sent from server. */, lineCount: number,
   /** Makes streamer to perform seek operation to given offset before sending the contents.
    * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
    * If undefined, then starts from the end. */
-
   offsetBytes?: number,
   /** Is substring for line search pattern.
    * This option makes controller to send to the client only lines, that
    * have given substring. */
-
   searchStr?: string): Promise<StreamingApiResponse>;
-  readText(/** A handle that was issued previously. */
-
-  handle: AnyLogHandle, /** Allows client to limit total data sent from server. */
-
-  lineCount: number,
+  readText(
+  /** A handle that was issued previously. */
+  handle: AnyLogHandle /** Allows client to limit total data sent from server. */, lineCount: number,
   /** Makes streamer to perform seek operation to given offset before sending the contents.
    * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
    * If undefined of 0, then starts from the beginning. */
-
   offsetBytes?: number,
   /** Is substring for line search pattern.
    * This option makes controller to send to the client only lines, that
    * have given substring. */
-
   searchStr?: string): Promise<StreamingApiResponse>;
 }
 /** Response of the driver.
@@ -3566,7 +3918,7 @@ type StreamingApiResponseHandleOutdated = {
   shouldUpdateHandle: true;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/column_filter.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/column_filter.d.ts
 //#region src/drivers/pframe/column_filter.d.ts
 /** Allows to search multiple columns in different contexts. */
 interface ColumnFilter {
@@ -3583,9 +3935,9 @@ interface ColumnFilter {
   /** Match requires all the annotations listed here to match corresponding regex
    * pattern. */
   readonly annotationPattern?: Record<string, string>;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/find_columns.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/find_columns.d.ts
 //#region src/drivers/pframe/find_columns.d.ts
 /**
  * Request to search among existing columns in the PFrame. Two filtering
@@ -3610,9 +3962,9 @@ interface FindColumnsRequest {
 interface FindColumnsResponse {
   /** Array of column ids found using request criteria. */
   readonly hits: PColumnIdAndSpec[];
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/unique_values.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/unique_values.d.ts
 //#region src/drivers/pframe/unique_values.d.ts
 /** Calculate set of unique values for a specific axis for the filtered set of records */
 interface UniqueValuesRequest {
@@ -3630,13 +3982,13 @@ interface UniqueValuesResponse {
   readonly values: PTableVector;
   /** True if limit was reached and response contain non-exhaustive list of values. */
   readonly overflow: boolean;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/pframe.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/pframe.d.ts
 /** Information required to instantiate a PFrame. */
-type PFrameDef<Col> = Col[]; //#endregion
+type PFrameDef<Col> = Col[];
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/driver.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/driver.d.ts
 //#region src/drivers/pframe/driver.d.ts
 /** PFrame handle */
 type PFrameHandle = Branded$1<string, "PFrame">;
@@ -3702,9 +4054,9 @@ interface PFrameDriver {
    * 1,000,000-row per-sheet limit (below Excel's hard cap of 1,048,576).
    */
   exportPTable(handle: PTableHandle, options: ExportPTableOptions): Promise<void>;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/ls.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/ls.d.ts
 //#region src/drivers/ls.d.ts
 type ImportFileHandleUpload = `upload://upload/${string}`;
 type ImportFileHandleIndex = `index://index/${string}`;
@@ -3716,7 +4068,7 @@ type StorageHandleLocal = `local://${string}`;
 type StorageHandleRemote = `remote://${string}`;
 type StorageHandle = StorageHandleLocal | StorageHandleRemote;
 type StorageEntry = {
-  /** Stable machine identifier (e.g. "library", "root", "local"). Used for filtering. */id: string; /** Human-readable display name. */
+  /** Stable machine identifier (e.g. "library", "root", "local"). Used for filtering. */ id: string; /** Human-readable display name. */
   name: string;
   handle: StorageHandle;
   initialFullPath: string;
@@ -3736,11 +4088,11 @@ type LsEntry = {
   handle: ImportFileHandle;
 };
 type OpenDialogFilter = {
-  /** Human-readable file type name */readonly name: string; /** File extensions */
+  /** Human-readable file type name */ readonly name: string; /** File extensions */
   readonly extensions: string[];
 };
 type OpenDialogOps = {
-  /** Open dialog window title */readonly title?: string; /** Custom label for the confirmation button, when left empty the default label will be used. */
+  /** Open dialog window title */ readonly title?: string; /** Custom label for the confirmation button, when left empty the default label will be used. */
   readonly buttonLabel?: string; /** Limits of file types user can select */
   readonly filters?: OpenDialogFilter[];
 };
@@ -3754,7 +4106,6 @@ type OpenMultipleFilesResponse = {
    * the dialog, field will be undefined. */
   readonly files?: LocalImportFileHandle[];
 };
-/** Can be used to limit request for local file content to a certain bytes range */
 interface LsDriver {
   /** remote and local storages */
   getStorageList(): Promise<StorageEntry[]>;
@@ -3777,9 +4128,8 @@ interface LsDriver {
   /** Saves currently opened block webview as a PDF. */
   exportToPdf?(): Promise<void>;
 }
-/** Gets a file path from an import handle. */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/columns/column_selector.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/column_selector.d.ts
 //#region src/columns/column_selector.d.ts
 /** Relaxed string matcher input: plain string, single matcher, or array of mixed. */
 type RelaxedStringMatchers = string | StringMatcher | (string | StringMatcher)[];
@@ -3806,7 +4156,7 @@ interface RelaxedColumnSelector {
 /** One or many relaxed column selectors; normalizes to MultiColumnSelector[]. */
 type ColumnSelector = RelaxedColumnSelector | RelaxedColumnSelector[];
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/discover_columns_options.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/discover_columns_options.d.ts
 //#region src/drivers/columns/discover_columns_options.d.ts
 /**
  * Axis matching behaviour applied to `discover` requests.
@@ -3823,7 +4173,6 @@ type MatchingMode = "enrichment" | "related" | "exact";
  * sandbox/host VM bridge unchanged.
  */
 type AnchorEntry = PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector;
-/** Qualifications needed for both already-integrated anchor columns and the hit column. */
 /**
  * Options object accepted by sandbox `discoverColumns()` and by the host
  * `ColumnsCollectionDriver.discover` / `.filter` methods. Pure JSON shape —
@@ -3854,9 +4203,8 @@ type ColumnsDiscoverOptions = DiscoverColumnsOptions;
  * of the filter surface — only `include` / `exclude` / `anchors`.
  */
 type ColumnsFilterOptions = Omit<DiscoverColumnsOptions, "mode" | "maxHops">;
-/** Translate a {@link MatchingMode} into the boolean-flag form the spec driver consumes. */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/columns/types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/types.d.ts
 //#region src/columns/types.d.ts
 /**
  * Opaque sandbox/host accessor handle.
@@ -3936,15 +4284,8 @@ interface AccessorLike<Self extends AccessorLike<Self>> {
   /** Decode the data payload as JSON. Returns `undefined` if no data. */
   getDataAsJson<T = unknown>(): T | undefined;
 }
-/**
- * One indexed column — the canonical record produced by every traversal.
- * Carries everything needed to read spec/data/status under a stable id.
- *
- * Generic over the accessor flavour so the same record shape works for both
- * the sandbox `TreeNodeAccessor` and the host `PlTreeNodeAccessor`.
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/columns_collection_driver.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/columns_collection_driver.d.ts
 //#region src/drivers/columns/columns_collection_driver.d.ts
 /**
  * Opaque host-owned handle for a `ColumnsCollection` instance. Issued by
@@ -4056,9 +4397,9 @@ interface ColumnsCollectionDriver {
   addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
   discover(handle: CollectionHandle, options: ColumnsDiscoverOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
   filter(handle: CollectionHandle, options: ColumnsFilterOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/services/service_types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_types.d.ts
 //#region src/services/service_types.d.ts
 type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType = ServiceType, ModelHost = Model, UiHost = Ui> = {
   readonly __types?: {
@@ -4081,24 +4422,23 @@ interface ServiceDispatch {
 }
 type TServices = typeof Services;
 type ExtractServiceName<T> = T extends Branded$1<infer N extends string, any> ? N : never;
-/** Model-side service interfaces keyed by service name literal. */
 /** UI-side service interfaces keyed by service name literal. */
-type UiServices$1 = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<ServiceBrand<TServices[K]>> };
+type UiServices$1 = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<ServiceBrand<TServices[K]>>; };
 /** Map from Services keys to their unbranded string name literals. */
-type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TServices[K]> };
+type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TServices[K]>; };
 /** Auto-derived requires* feature flags from Services keys. */
-type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean };
+type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean; };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.d.ts
 //#region src/services/service_declarations.d.ts
 declare const Services: {
   PFrameSpec: Branded$1<"pframeSpec", ServiceTypesLike<PFrameSpecDriver, PFrameSpecDriver, "wasm", PFrameSpecDriver, PFrameSpecDriver>>;
   PFrame: Branded$1<"pframe", ServiceTypesLike<PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver, "node", PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver>>;
   Dialog: Branded$1<"dialog", ServiceTypesLike<Record<string, never>, DialogService, "main", Record<string, never>, DialogService>>;
   ColumnsCollection: Branded$1<"columnsCollection", ServiceTypesLike<ColumnsCollectionDriverModel, ColumnsCollectionDriverModel, "wasm", ColumnsCollectionDriver, ColumnsCollectionDriver>>;
-}; //#endregion
+};
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.d.ts
 /**
  * Known block flags. Flags are set during model compilation, see `BlockModel.create` for more details and for initial values.
  */
@@ -4110,13 +4450,8 @@ type BlockCodeKnownFeatureFlags = {
   readonly requiresCreatePTable?: number;
   readonly requiresPFramesVersion?: number;
 } & ServiceRequireFlags;
-/**
- * Required PFrames version. Bump this in lockstep with the `@milaboratories/pframes-rs-*`
- * version in `pnpm-workspace.yaml` so blocks built against the new SDK refuse to load on
- * older desktop apps.
- */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/driver_kit.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/driver_kit.d.ts
 //#region src/driver_kit.d.ts
 /** Set of all drivers exposed in UI SDK via the platforma object. */
 interface DriverKit {
@@ -4135,9 +4470,9 @@ interface DriverKit {
   readonly lsDriver: LsDriver;
   /** Driver allowing to interact with PFrames and PTables */
   readonly pFrameDriver: PFrameDriver;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/errors.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/errors.d.ts
 type ResultOrError<S, F = Error> = {
   value: S;
   error?: undefined;
@@ -4145,7 +4480,7 @@ type ResultOrError<S, F = Error> = {
   error: F;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/utag.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/utag.d.ts
 //#region src/utag.d.ts
 /** Value returned for changing states supporting reactive listening for changes */
 interface ValueWithUTag<V> {
@@ -4162,21 +4497,21 @@ interface ValueWithUTag<V> {
 }
 interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
   readonly author?: AuthorMarker;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_state_patch.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_state_patch.d.ts
 //#region src/block_state_patch.d.ts
 /** Patch for the structural object */
 type Patch<K, V> = {
-  /** Field name to patch */readonly key: K; /** New value for the field */
+  /** Field name to patch */ readonly key: K; /** New value for the field */
   readonly value: V;
 };
 /** Creates union type of all possible shallow patches for the given structure */
-type Unionize<T extends Record<string, unknown>> = { [K in keyof T]: Patch<K, T[K]> }[keyof T];
+type Unionize<T extends Record<string, unknown>> = { [K in keyof T]: Patch<K, T[K]>; }[keyof T];
 /** Patch for the BlockState, pushed by onStateUpdates method in SDK. */
-type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>; //#endregion
+type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/plugin_handle.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/plugin_handle.d.ts
 //#region src/plugin_handle.d.ts
 /**
  * Phantom-only base type for constraining PluginHandle's type parameter.
@@ -4196,16 +4531,14 @@ interface PluginFactoryLike<Data extends Record<string, unknown> = Record<string
     uiServices: UiServices;
   };
 }
-/** Extract the Data type from a PluginFactoryLike phantom. */
 /**
  * Opaque handle for a plugin instance. Runtime value is the plugin instance ID string.
  * Branded with factory phantom `F` for type-safe data/outputs extraction.
  * Constrained with PluginFactoryLike (not PluginFactory) to avoid variance issues.
  */
 type PluginHandle<F extends PluginFactoryLike = PluginFactoryLike> = Branded<string, F>;
-/** Construct the output key for a plugin output in the block outputs map. */
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_storage.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_storage.d.ts
 /** Payload for storage mutation operations. SDK defines specific operations. */
 type MutateStoragePayload<T = unknown> = {
   operation: "update-block-data";
@@ -4215,15 +4548,8 @@ type MutateStoragePayload<T = unknown> = {
   pluginId: PluginHandle;
   value: unknown;
 };
-/**
- * Updates the data in BlockStorage (immutable)
- *
- * @param storage - The current BlockStorage
- * @param payload - The update payload with operation and value
- * @returns A new BlockStorage with updated data
- */
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/bconfig/lambdas.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/bconfig/lambdas.d.ts
 /** Additional information that may alter lambda rendering procedure. */
 type ConfigRenderLambdaFlags = {
   /**
@@ -4252,15 +4578,14 @@ interface ConfigRenderLambda<Return = unknown> extends ConfigRenderLambdaFlags {
   handle: string;
 }
 type ExtractFunctionHandleReturn<Func extends ConfigRenderLambda> = Func extends ConfigRenderLambda<infer Return> ? Return : never;
-/** Infers the output type from a TypedConfig or ConfigRenderLambda */
 /** Maps lambda-only outputs configuration to inferred output types (for V3 blocks) */
 type InferOutputsFromLambdas<OutputsCfg extends Record<string, ConfigRenderLambda>> = { [Key in keyof OutputsCfg]: OutputWithStatus<ExtractFunctionHandleReturn<OutputsCfg[Key]>> & {
   __unwrap: OutputsCfg[Key] extends {
     withStatus: true;
   } ? false : true;
-} }; //#endregion
+}; };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_api_v1.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_api_v1.d.ts
 //#region src/block_api_v1.d.ts
 /** Returned by state subscription methods to be able to cancel the subscription. */
 type CancelSubscription = () => void;
@@ -4320,7 +4645,7 @@ interface BlockApiV1<Args = unknown, Outputs extends BlockOutputsBase = BlockOut
    * Sets block navigation state.
    * */
   setNavigationState(state: NavigationState<Href>): Promise<void>;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/fast-json-patch@3.1.1/node_modules/fast-json-patch/module/core.d.ts
 declare type Operation = AddOperation<any> | RemoveOperation | ReplaceOperation<any> | MoveOperation | CopyOperation | TestOperation<any> | GetOperation<any>;
@@ -4355,7 +4680,7 @@ interface GetOperation<T> extends BaseOperation {
   value: T;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_api_v2.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_api_v2.d.ts
 //#region src/block_api_v2.d.ts
 /** Defines methods to read and write current block data. */
 interface BlockApiV2<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> {
@@ -4403,14 +4728,14 @@ interface BlockApiV2<Args = unknown, Outputs extends BlockOutputsBase = BlockOut
    * Disposes the block API.
    * */
   dispose(): Promise<ResultOrError<void>>;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/version.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/version.d.ts
 type SdkInfo = {
   readonly sdkVersion: string;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/services/block_services.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/services/block_services.d.ts
 //#region src/services/block_services.d.ts
 /**
  * Services required by all V3 blocks by default.
@@ -4427,14 +4752,14 @@ declare const BLOCK_SERVICE_FLAGS: {
 };
 type BlockServiceFlags = typeof BLOCK_SERVICE_FLAGS;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/services/service_resolve.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/services/service_resolve.d.ts
 //#region src/services/service_resolve.d.ts
 type FlagToName<Flag extends string> = Flag extends `requires${infer K}` ? K extends keyof ServiceNameLiterals ? ServiceNameLiterals[K] : never : never;
-type RequiredServiceNames<Flags> = { [K in keyof Flags & `requires${string}`]: Flags[K] extends true ? FlagToName<K & string> : never }[keyof Flags & `requires${string}`];
+type RequiredServiceNames<Flags> = { [K in keyof Flags & `requires${string}`]: Flags[K] extends true ? FlagToName<K & string> : never; }[keyof Flags & `requires${string}`];
 type ResolveUiServices<Flags> = Pick<UiServices$1, RequiredServiceNames<Flags> & keyof UiServices$1>;
-type BlockDefaultUiServices = ResolveUiServices<BlockServiceFlags>; //#endregion
+type BlockDefaultUiServices = ResolveUiServices<BlockServiceFlags>;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/plugin_model.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/plugin_model.d.ts
 /**
  * Runtime definition for a single public output field.
  * Stored in PluginModel and passed through BlockModelInfo to the UI layer.
@@ -4443,7 +4768,7 @@ type PublicOutputFieldDef = {
   readonly getter: (data: unknown) => unknown;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_api_v3.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_api_v3.d.ts
 //#region src/block_api_v3.d.ts
 /** Defines methods to read and write current block data. */
 interface BlockApiV3<_Data = unknown, _Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> {
@@ -4472,9 +4797,9 @@ interface BlockApiV3<_Data = unknown, _Args = unknown, Outputs extends BlockOutp
    * Disposes the block API.
    * */
   dispose(): Promise<ResultOrError<void>>;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/platforma.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/platforma.d.ts
 //#region src/platforma.d.ts
 /** Defines all methods to interact with the platform environment from within a block UI. @deprecated */
 interface PlatformaV1<Args = unknown, Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>, UiState = unknown, Href extends `/${string}` = `/${string}`> extends BlockApiV1<Args, Outputs, UiState, Href>, DriverKit {
@@ -4515,29 +4840,48 @@ type InferOutputsType<Pl extends Platforma> = Pl extends Platforma<unknown, infe
 type InferDataType<Pl extends Platforma> = Pl extends Platforma<unknown, Record<string, OutputWithStatus<unknown>>, infer Data> ? Data : never;
 type InferHrefType<Pl extends Platforma> = Pl extends Platforma<unknown, BlockOutputsBase, unknown, infer Href> ? Href : never;
 //#endregion
-//#region ../model/dist/types.d.ts
+//#region ../kind/dist/types.d.ts
 //#region src/types.d.ts
+/**
+ * The types the block's init-params contract is built from.
+ *
+ * They live in the kind, not in the model, because the kind owns the contract:
+ * `BlockParams` is what a project template serializes, and a second copy of these
+ * shapes in the model would drift the moment one side gains a case the other
+ * misses. The model re-exports them from here, so every existing import path
+ * keeps working.
+ */
 /** Receptor type. Same enum as sequence-properties to keep label conventions aligned. */
 type WorkflowReceptor = "IG" | "TCRAB" | "TCRGD";
 /**
- * ESM-2 fidelity the user picks per card, projected into args. Default is `standard`.
- * `standard` → ESM-2 150M; `high` → ESM-2 650M. Only meaningful when the card's
+ * A scope's receptor, or `"unknown"` when the producer declares VDJ data but no
+ * receptor at all.
+ *
+ * `synthetic-repertoire-profiler` is the case: it declares `pl7.app/modality: vdj`
+ * but emits neither `pl7.app/vdj/receptor` nor `pl7.app/vdj/chain` — germline
+ * auto-detection builds a custom reference from the user's own parent sequences, so
+ * there is no library locus to read a receptor from. Guessing `IG` there would
+ * silently exclude the TCR specialists from a TCR dataset, so the unknown is carried
+ * explicitly and `compat.ts` relaxes receptor/chain gating rather than filtering on
+ * a value nobody supplied.
+ *
+ * Widening only — every previously persisted `WorkflowReceptor` stays valid, so
+ * snapshotted scopes in existing projects deserialize unchanged.
+ */
+type ScopeReceptor = WorkflowReceptor | "unknown";
+/**
+ * ESM-2 fidelity the user picks, projected into args. Default is `standard`.
+ * `standard` → ESM-2 150M; `high` → ESM-2 650M. Only meaningful when the
  * model is ESM-2; ignored for the single-checkpoint specialists.
  */
 type Fidelity = "high" | "standard";
 /**
- * User-facing embedding-model choice — the value of a card's model dropdown. A
+ * User-facing embedding-model choice — the value of the model dropdown. A
  * logical id; the workflow maps it (plus `Fidelity` for ESM-2) to a concrete
- * checkpoint `ModelTag`. The catalog and scope↔model compatibility live in
- * `compat.ts`.
+ * checkpoint `ModelTag`. The catalog and scope↔model compatibility live in the
+ * model package's `compat.ts`.
  */
 type EmbeddingModelId = "esm2" | "ablang2" | "currab" | "vhhbert" | "h3berta" | "tcr-bert" | "peptideclm2" | "sceptr";
-/**
- * Checkpoint tag emitted on the `pl7.app/embedding/model` domain of every output
- * column (model provenance). ESM-2 splits by fidelity; specialists are 1:1 with
- * their `EmbeddingModelId`.
- */
-type ModelTag = "esm2-650M" | "esm2-150M" | "ablang2" | "currab" | "vhhbert" | "h3berta" | "tcr-bert" | "peptideclm2" | "sceptr";
 /** Embedding scope feature. `Fv` and `scFv` span/merge chains and carry no `chain`. */
 type ScopeFeature = "peptide" | "CDR3" | "VDJRegion" | "Fv" | "scFv";
 /**
@@ -4546,9 +4890,14 @@ type ScopeFeature = "peptide" | "CDR3" | "VDJRegion" | "Fv" | "scFv";
  * for single-chain scopes, two (`[VH, VL]`) for the paired Fv scope. The column
  * ids (and `isHeavy`/`receptor`) are snapshotted into `BlockData` on the user's
  * gesture (the anchored-id storage pattern), so the args lambda stays `data`-only.
+ *
+ * Those ids are anchored — they resolve against the block's own `inputAnchor`.
+ * That is why a template that carries a scope must carry the matching
+ * `inputAnchor` too; the two params travel as a pair or not at all.
  */
 type SelectedScope = {
-  /** Stable picker key. The sequence column id for single scopes; `"Fv"` for paired Fv. */id: string;
+  /** Stable picker key. The sequence column id for single scopes; `"Fv"` for paired Fv. */
+  id: string;
   feature: ScopeFeature;
   chain: "A" | "B" | "";
   columns: SUniversalPColumnId[];
@@ -4557,13 +4906,17 @@ type SelectedScope = {
    * True when this is an IG heavy chain (single-cell chain `A`, or bulk
    * `IGHeavy`). Gates the heavy-only specialists (VHHBERT, H3BERTa) and the
    * VHH-vs-mAb default. Snapshotted so the args lambda stays `data`-only.
+   *
+   * Always `false` when `receptor` is `"unknown"` — a producer that supplies no
+   * receptor supplies no chain either, so this carries no information there and
+   * `compat.ts` does not gate on it.
    */
   isHeavy: boolean;
   /** Receptor of the input this scope came from, snapshotted for `data`-only
-   *  compatibility validation in the args lambda. */
-  receptor: WorkflowReceptor;
+   *  compatibility validation in the args lambda. `"unknown"` when the producer
+   *  declares VDJ data without a receptor — see `ScopeReceptor`. */
+  receptor: ScopeReceptor;
 };
-/** A selectable scope. Alias of `SelectedScope` — the label lives on the base type. */
 /**
  * The single (sequence scope, model) selection the user assembles. `scope` and
  * `model` are each undefined until picked — the UI fills one and bidirectionally
@@ -4573,15 +4926,20 @@ type SelectedScope = {
  */
 type EmbeddingSelection = {
   scope?: SelectedScope;
-  model?: EmbeddingModelId; /** ESM-2 fidelity; ignored for other models. */
+  model?: EmbeddingModelId;
+  /** ESM-2 fidelity; ignored for other models. */
   fidelity?: Fidelity;
 };
+//#endregion
+//#endregion
+//#region ../model/dist/types.d.ts
+//#region src/types.d.ts
 /**
- * Frozen V2 card shape (per-card model selection, before the single-selection
- * redesign). Kept only as the migration source type so `BlockDataV2` stays
- * historically accurate; new code uses `EmbeddingSelection`. `id` was the stable
- * key for V2's `PlElementList`; dropped in V3.
+ * Checkpoint tag emitted on the `pl7.app/embedding/model` domain of every output
+ * column (model provenance). ESM-2 splits by fidelity; specialists are 1:1 with
+ * their `EmbeddingModelId`.
  */
+type ModelTag = "esm2-650M" | "esm2-150M" | "ablang2" | "currab" | "vhhbert" | "h3berta" | "tcr-bert" | "peptideclm2" | "sceptr";
 /**
  * V3 BlockData. The card list collapses to a single (scope, model) selection: the
  * block embeds ONE combination per run. `embedding` is always present (init `{}`);
@@ -4589,26 +4947,28 @@ type EmbeddingSelection = {
  * contract is unchanged.
  */
 type BlockDataV3 = {
-  inputAnchor?: PlRef; /** The single (scope, model, fidelity?) selection the user assembles. */
+  inputAnchor?: PlRef;
+  /** The single (scope, model, fidelity?) selection the user assembles. */
   embedding: EmbeddingSelection;
   /**
    * Init-guard: canonical id of the anchor whose default selection was last seeded.
    * Prevents re-seeding on panel reopen / server patch; triggers a re-seed on
    * input change.
    */
-  embeddingInitializedForAnchor?: string; /** Advanced resource overrides (GiB / cores); undefined → workflow sizes automatically from device + input. */
+  embeddingInitializedForAnchor?: string;
+  /** Advanced resource overrides (GiB / cores); undefined → workflow sizes automatically from device + input. */
   mem?: number;
   cpu?: number;
   defaultBlockLabel?: string;
 };
-/** Current BlockData shape. */
 /**
  * One embedding task in the workflow input: a scope plus the model to embed it
  * with (and ESM-2 fidelity, when applicable). Projected from `BlockData.embedding`.
  */
 type EmbeddingTask = {
   scope: SelectedScope;
-  model: EmbeddingModelId; /** ESM-2 fidelity; undefined for other models. */
+  model: EmbeddingModelId;
+  /** ESM-2 fidelity; undefined for other models. */
   fidelity?: Fidelity;
 };
 /**
@@ -4618,11 +4978,13 @@ type EmbeddingTask = {
  * `.argsValid()`).
  */
 type BlockArgs = {
-  inputAnchor: PlRef; /** Tasks to emit — a 1-element list projected from `data.embedding` (validated complete + compatible). */
-  embeddings: EmbeddingTask[]; /** Advanced resource overrides for the embedding step (GiB / cores); undefined → workflow sizes automatically. */
+  inputAnchor: PlRef;
+  /** Tasks to emit — a 1-element list projected from `data.embedding` (validated complete + compatible). */
+  embeddings: EmbeddingTask[];
+  /** Advanced resource overrides for the embedding step (GiB / cores); undefined → workflow sizes automatically. */
   mem?: number;
   cpu?: number;
-}; //#endregion
+};
 //#endregion
 //#region ../model/dist/index.d.ts
 //#region src/index.d.ts
@@ -4632,7 +4994,7 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV3, BlockArgs, I
       readonly __isRef: true;
       readonly blockId: string;
       readonly name: string;
-      readonly requireEnrichments?: true | undefined | undefined;
+      readonly requireEnrichments?: true | undefined;
     };
     readonly label: string;
   }[]>;
@@ -4645,7 +5007,7 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV3, BlockArgs, I
       columns: SUniversalPColumnId[];
       label: string;
       isHeavy: boolean;
-      receptor: WorkflowReceptor;
+      receptor: ScopeReceptor;
     }[];
     defaults: {
       id: string;
@@ -4654,28 +5016,28 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV3, BlockArgs, I
       columns: SUniversalPColumnId[];
       label: string;
       isHeavy: boolean;
-      receptor: WorkflowReceptor;
+      receptor: ScopeReceptor;
     }[];
     forAnchor: string;
-    receptor: WorkflowReceptor;
+    receptor: ScopeReceptor;
     paired: boolean;
   } | undefined>;
 } & {
   stats: ConfigRenderLambda<{
     device_used: "cpu" | "cuda" | "mps";
-    device_requested?: "cpu" | "gpu" | undefined;
+    device_requested?: "cpu" | "gpu";
     model: ModelTag;
-    max_length?: number | undefined;
+    max_length?: number;
     scopes: {
       name: string;
       feature: "peptide" | "CDR3" | "VDJRegion" | "Fv" | "scFv";
       chain: "A" | "B" | "";
       label: string;
       model: ModelTag;
-      max_length?: number | undefined;
-      n_entities?: number | undefined;
-      n_dropped_empty?: number | undefined;
-      n_truncated?: number | null | undefined;
+      max_length?: number;
+      n_entities?: number;
+      n_dropped_empty?: number;
+      n_truncated?: number | null;
     }[];
   } | undefined>;
 } & {