@routier/core 0.2.0 → 0.3.0

package/dist/schema/property/base/SchemaBase.d.ts

@@ -1,4 +1,4 @@
-import { DefaultValue, FunctionBody, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
+import { DefaultValue, ForeignKey, FunctionBody, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes, PropertyTransform } from "../../types";
 export declare abstract class SchemaBase<T extends any, TModifiers extends SchemaModifiers> {
     abstract instance: T;
     modifiers: TModifiers;
@@ -8,9 +8,57 @@ export declare abstract class SchemaBase<T extends any, TModifiers extends Schem
     isKey: boolean;
     isIdentity: boolean;
     isReadonly: boolean;
-    isDistict: boolean;
+    isDistinct: boolean;
+    /**
+     * Set by `.modify(x => x.transform(...))`. A live reference, never stringified.
+     * `null` when the property is stored as it is.
+     */
+    transform: PropertyTransform<unknown> | null;
     indexes: string[];
     fromPropertyName: string | null;
+    /**
+     * How many numbers a vector holds. `null` for every other type.
+     *
+     * Declared here rather than on `SchemaVector` because a modifier WRAPS rather than
+     * extends: `s.vector(1536).optional()` is a `SchemaOptional`, and anything reachable only
+     * through the original class is lost the moment a modifier is added. `type` survives for
+     * exactly this reason — the copy constructor below carries it — and a dimension count has
+     * to travel with it, or an optional vector reaches a backend as a vector of unknown width
+     * and cannot be given a column.
+     *
+     * `innerSchema` is the cautionary example: it lives on `SchemaArray` alone, so a modified
+     * array arrives with no element type and clones through the slow path.
+     */
+    dimensions: number | null;
+    /**
+     * The longest string the property is declared to hold. `null` for every other type, and
+     * for a string that declares nothing.
+     *
+     * Declared here rather than on `SchemaString` for the same reason as `dimensions` above:
+     * `s.string({ maxLength: 4000 }).optional()` is a `SchemaOptional`, so anything reachable
+     * only through `SchemaString` is lost the moment a modifier is added.
+     *
+     * A declaration, never a validation. Core does not check a value against it and does not
+     * truncate. The backend that can use the number does: MySQL gives the column
+     * `VARCHAR(maxLength)` instead of the blanket `VARCHAR(255)`. Every other backend ignores
+     * it, because a string column that is already unbounded cannot be made more correct by
+     * knowing a bound.
+     */
+    maxLength: number | null;
+    /**
+     * Whether this string may be tokenised into a full-text search index.
+     *
+     * Set by `.searchable()`, and only ever true on a string. Eligibility, not membership: a
+     * collection that never declares `.searchIndex()` indexes nothing regardless.
+     *
+     * Copied by the constructor below, so `s.string().searchable().optional()` stays searchable.
+     * Every flag on this class is copied for the same reason: a modifier WRAPS rather than
+     * extends, so anything the constructor forgets is silently dropped the moment a property
+     * gains one more modifier.
+     */
+    isSearchable: boolean;
+    foreignKeyDefinition: ForeignKey<unknown> | null;
+    tags: string[];
     injected: any;
     defaultValue: DefaultValue<T> | null;
     valueSerializer: PropertySerializer<T> | null;

package/dist/schema/property/modifiers/SchemaDeserialize.d.ts

@@ -1,6 +1,8 @@
-import { PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
+import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "./SchemaDefault";
 import { SchemaFrom } from "./SchemaFrom";
+import { SchemaOptional } from "./SchemaOptional";
 import { SchemaSerialize } from "./SchemaSerialize";
 export declare class SchemaDeserialize<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -8,4 +10,6 @@ export declare class SchemaDeserialize<T extends any, TModifiers extends SchemaM
     constructor(deserializer: PropertyDeserializer<T>, current: SchemaBase<T, TModifiers>);
     serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
     from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    default<I = never>(value: DefaultValue<T | null, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaForeignKey.d.ts

@@ -0,0 +1,15 @@
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaIdentity } from "./SchemaIdentity";
+import { SchemaDefault } from "./SchemaDefault";
+import { CompiledSchema, DefaultValue, InferType, SchemaModifiers } from "../../types";
+import { SchemaFrom } from "./SchemaFrom";
+import { SchemaTag } from "./SchemaTag";
+export declare class SchemaForeignKey<T extends any, TModifiers extends SchemaModifiers, K extends {}> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaForeignKey;
+    constructor(current: SchemaBase<T, TModifiers>, relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>);
+    identity(): SchemaIdentity<T, "identity" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaKey.d.ts

@@ -3,6 +3,7 @@ import { SchemaIdentity } from "./SchemaIdentity";
 import { SchemaDefault } from "./SchemaDefault";
 import { DefaultValue, IdType, SchemaModifiers } from "../../types";
 import { SchemaFrom } from "./SchemaFrom";
+import { SchemaTag } from "./SchemaTag";
 export declare class SchemaKey<T extends IdType, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaKey;
@@ -10,4 +11,5 @@ export declare class SchemaKey<T extends IdType, TModifiers extends SchemaModifi
     identity(): SchemaIdentity<T, "identity" | TModifiers>;
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     from(propertyName: string): SchemaFrom<T, TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaNullable.d.ts

@@ -1,9 +1,23 @@
-import { SchemaModifiers } from "../../types";
+import { DefaultValue, PropertyDeserializer, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "./SchemaDefault";
+import { SchemaDeserialize } from "./SchemaDeserialize";
 import { SchemaOptional } from "./SchemaOptional";
+import { SchemaSearchable } from "./SchemaSearchable";
 export declare class SchemaNullable<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaNullable;
     constructor(current: SchemaBase<T, TModifiers>);
     optional(): SchemaOptional<T, "optional" | TModifiers>;
+    /**
+     * Only callable when the property underneath is a string — see the same method on
+     * `SchemaOptional` for why the constraint is on `instance` rather than the whole class.
+     *
+     * A null value contributes no tokens.
+     */
+    searchable(this: {
+        instance: string;
+    }): SchemaSearchable<T, "searchable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T | null, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T | null>): SchemaDeserialize<T, "deserialize" | TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaOptional.d.ts

@@ -1,9 +1,30 @@
-import { SchemaModifiers } from "../../types";
+import { PropertyDeserializer, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDeserialize } from "./SchemaDeserialize";
 import { SchemaNullable } from "./SchemaNullable";
+import { SchemaSearchable } from "./SchemaSearchable";
 export declare class SchemaOptional<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaOptional;
     constructor(current: SchemaBase<T, TModifiers>);
     nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    /**
+     * Only callable when the property underneath is a string.
+     *
+     * A wrapper does not know what it wraps at runtime, but the type does: `T` is the value
+     * type, so `s.number().optional()` is a `SchemaOptional<number>` and fails this `this`
+     * constraint. That is the gate — there is no runtime check, because a builder that offers
+     * a method it will then reject has already failed at its job.
+     *
+     * Constrained on `instance` alone rather than the whole class. `SchemaBase` holds `T` in
+     * contravariant positions too (`valueSerializer`, `defaultValue`), so requiring the full
+     * `SchemaOptional<string, ...>` would reject a literal union like
+     * `s.string("draft", "published")`, which is a perfectly good searchable string.
+     *
+     * An absent value contributes no tokens.
+     */
+    searchable(this: {
+        instance: string;
+    }): SchemaSearchable<T, "searchable" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T | undefined>): SchemaDeserialize<T, "deserialize" | TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaSearchable.d.ts

@@ -0,0 +1,34 @@
+import { SchemaModifiers } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaNullable } from "./SchemaNullable";
+import { SchemaOptional } from "./SchemaOptional";
+/**
+ * Marks a string property as eligible for a full-text search index.
+ *
+ * Eligible, not indexed. The schema says what COULD be indexed; the collection builder's
+ * `.searchIndex()` says that it IS. A property marked here on a collection that never declares
+ * an index costs nothing at all — no rows, no write amplification, no storage.
+ *
+ * Like `s.vector()`, this exists to be RECOGNISED rather than to behave. It changes nothing
+ * about how the property is stored, cloned, compared, serialized or queried. The datastore
+ * reads the flag off the compiled schema to decide which values to tokenise; every plugin is
+ * unaware the property is any different from another string.
+ *
+ * Declared on `SchemaString` only, so `s.number().searchable()` is a compile error rather than
+ * a runtime surprise. The one case the type system cannot catch — a searchable string nested
+ * inside an `s.object()` — is rejected when the schema compiles: v1 indexes root-level string
+ * properties only.
+ */
+export declare class SchemaSearchable<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaSearchable;
+    constructor(current: SchemaBase<T, TModifiers>);
+    /**
+     * Declared here so `.searchable()` composes in BOTH senses — `.searchable().optional()` and
+     * `.optional().searchable()` mean the same thing and both keep the flag. `SchemaDistinct`
+     * exposes neither, which is why `.distinct().optional()` is unwritable and its copy-loss
+     * (see `SchemaBase.isSearchable`) has never been noticed.
+     */
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaTag.d.ts

@@ -0,0 +1,27 @@
+import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaArray } from "../types";
+import { SchemaDefault } from "./SchemaDefault";
+import { SchemaDeserialize } from "./SchemaDeserialize";
+import { SchemaDistinct } from "./SchemaDistinct";
+import { SchemaFrom } from "./SchemaFrom";
+import { SchemaIndex } from "./SchemaIndex";
+import { SchemaNullable } from "./SchemaNullable";
+import { SchemaOptional } from "./SchemaOptional";
+import { SchemaReadonly } from "./SchemaReadonly";
+import { SchemaSerialize } from "./SchemaSerialize";
+export declare class SchemaTag<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaTag;
+    constructor(tags: string[], current: SchemaBase<T, TModifiers>);
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T, TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaTracked.d.ts

@@ -1,9 +1,13 @@
-import { IdType, SchemaModifiers } from "../../types";
+import { CompiledSchema, IdType, InferType, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaForeignKey } from "./SchemaForeignKey";
 import { SchemaKey } from "./SchemaKey";
+import { SchemaTag } from "./SchemaTag";
 export declare class SchemaTracked<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaTracked;
     constructor(current: SchemaBase<T, TModifiers>);
     key(): T extends IdType ? SchemaKey<T, TModifiers | "key"> : never;
+    foreignKey<K extends {}>(relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>): SchemaForeignKey<T, TModifiers, K>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/modifiers/index.d.ts

@@ -7,6 +7,9 @@ export * from './SchemaKey';
 export * from './SchemaNullable';
 export * from './SchemaOptional';
 export * from './SchemaReadonly';
+export * from './SchemaSearchable';
 export * from './SchemaSerialize';
 export * from './SchemaTracked';
 export * from './SchemaFrom';
+export * from './SchemaTag';
+export * from './SchemaForeignKey';

package/dist/schema/property/types/SchemaArray.d.ts

@@ -7,6 +7,7 @@ import { SchemaSerialize } from '../modifiers/SchemaSerialize';
 import { SchemaIndex } from "../modifiers/SchemaIndex";
 import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
 import { SchemaFrom } from "../modifiers/SchemaFrom";
+import { SchemaTag } from "../modifiers/SchemaTag";
 export declare class SchemaArray<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T[], TModifiers> {
     instance: T[];
     type: SchemaTypes;
@@ -20,4 +21,5 @@ export declare class SchemaArray<T extends any, TModifiers extends SchemaModifie
     deserialize(deserializer: PropertyDeserializer<T[]>): SchemaDeserialize<T[], "deserialize" | TModifiers>;
     serialize(serializer: PropertySerializer<T[]>): SchemaSerialize<T[], "serialize" | TModifiers>;
     index(...indexes: string[]): SchemaIndex<T[], TModifiers>;
+    tag(...tags: string[]): SchemaTag<T[], TModifiers>;
 }

package/dist/schema/property/types/SchemaBoolean.d.ts

@@ -9,6 +9,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaBoolean<T extends boolean, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -24,4 +25,5 @@ export declare class SchemaBoolean<T extends boolean, TModifiers extends SchemaM
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaDate.d.ts

@@ -9,6 +9,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaDate<T extends Date, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -24,4 +25,5 @@ export declare class SchemaDate<T extends Date, TModifiers extends SchemaModifie
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaFile.d.ts

@@ -0,0 +1,60 @@
+import { DefaultValue, SchemaModifiers, SchemaTypes } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "../modifiers/SchemaDefault";
+import { SchemaFrom } from "../modifiers/SchemaFrom";
+import { SchemaNullable } from "../modifiers/SchemaNullable";
+import { SchemaOptional } from "../modifiers/SchemaOptional";
+import { SchemaReadonly } from "../modifiers/SchemaReadonly";
+import { SchemaTag } from "../modifiers/SchemaTag";
+/**
+ * A file: content on the way in, a reference on the way out.
+ *
+ * This is the one property type whose write shape differs from its stored shape. You assign
+ * a `File`, a `Blob`, a `Uint8Array` or a string; what is stored, and what a query gives
+ * back, is a reference — where the bytes live and what they are.
+ *
+ * ```ts
+ * const documentSchema = s.define('documents', {
+ *     id: s.string().key().identity(),
+ *     title: s.string(),
+ *     file: s.file(),
+ * }).compile();
+ *
+ * await store.documents.addAsync({ title: 'Q3', file: fileFromInput });
+ * await store.saveChangesAsync();
+ *
+ * doc.file.size          // 2_400_112
+ * doc.file.contentType   // 'application/pdf'
+ * ```
+ *
+ * ## Why this cannot be `s.object({ key, size, ... })`
+ *
+ * The generated `preprocess` rebuilds an object property field by field from its declared
+ * children — `result.file = {}` and then one assignment per child. Content assigned there is
+ * therefore discarded by construction, before any plugin sees the entity: the property does
+ * not arrive mangled, it does not arrive at all.
+ *
+ * A file is a LEAF here, with no child properties, so the generated code passes it through
+ * untouched. The bytes survive as far as the plugin, which is the only place an upload can
+ * happen — `preprocess` is synchronous and is called from the change tracker and the
+ * broadcast path, so it cannot await one.
+ *
+ * ## What actually stores it
+ *
+ * Nothing in core uploads anything. `@routier/blob-plugin` wraps your real plugin, swaps
+ * pending content for a reference during `bulkPersist`, and hands the reference down. Without
+ * that wrapper a file property stores whatever you assigned, which is a mistake this type
+ * cannot detect on its own.
+ */
+export declare class SchemaFile<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaFile;
+    constructor();
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
+}

package/dist/schema/property/types/SchemaNumber.d.ts

@@ -1,8 +1,9 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
+import { CompiledSchema, DefaultValue, InferType, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
 import { SchemaDefault } from "../modifiers/SchemaDefault";
 import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
 import { SchemaDistinct } from "../modifiers/SchemaDistinct";
+import { SchemaForeignKey } from "../modifiers/SchemaForeignKey";
 import { SchemaFrom } from "../modifiers/SchemaFrom";
 import { SchemaIdentity } from "../modifiers/SchemaIdentity";
 import { SchemaIndex } from "../modifiers/SchemaIndex";
@@ -11,6 +12,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaNumber<T extends number, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -21,6 +23,7 @@ export declare class SchemaNumber<T extends number, TModifiers extends SchemaMod
     optional(): SchemaOptional<T, "optional" | TModifiers>;
     nullable(): SchemaNullable<T, "nullable" | TModifiers>;
     key(): SchemaKey<T, "key" | TModifiers>;
+    foreignKey<K extends {}>(relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>): SchemaForeignKey<T, TModifiers, K>;
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
     deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
@@ -29,4 +32,5 @@ export declare class SchemaNumber<T extends number, TModifiers extends SchemaMod
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaObject.d.ts

@@ -5,6 +5,7 @@ import { SchemaFrom } from "../modifiers/SchemaFrom";
 import { SchemaIdentity } from "../modifiers/SchemaIdentity";
 import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaObject<T extends {}, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -17,4 +18,5 @@ export declare class SchemaObject<T extends {}, TModifiers extends SchemaModifie
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     identity(): SchemaIdentity<T, "identity" | "readonly" | TModifiers>;
     array(): SchemaArray<this, TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaString.d.ts

@@ -1,8 +1,9 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
+import { CompiledSchema, DefaultValue, InferType, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes, StringOptions } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
 import { SchemaDefault } from "../modifiers/SchemaDefault";
 import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
 import { SchemaDistinct } from "../modifiers/SchemaDistinct";
+import { SchemaForeignKey } from "../modifiers/SchemaForeignKey";
 import { SchemaFrom } from "../modifiers/SchemaFrom";
 import { SchemaIdentity } from "../modifiers/SchemaIdentity";
 import { SchemaIndex } from "../modifiers/SchemaIndex";
@@ -10,17 +11,26 @@ import { SchemaKey } from "../modifiers/SchemaKey";
 import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
+import { SchemaSearchable } from "../modifiers/SchemaSearchable";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaString<T extends string, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     type: SchemaTypes;
     private _schemaString;
+    /**
+     * @param entity Copied from when a modifier wraps this property.
+     * @param literals The allowed values, when the string is a literal union.
+     * @param options Declarations a backend may use. See `StringOptions`.
+     */
+    constructor(entity?: SchemaBase<T, TModifiers> | null, literals?: T[], options?: StringOptions);
     from(propertyName: string): SchemaFrom<T, TModifiers>;
     constrain<K extends T>(): SchemaString<K, TModifiers>;
     optional(): SchemaOptional<T, "optional" | TModifiers>;
     nullable(): SchemaNullable<T, "nullable" | TModifiers>;
     key(): SchemaKey<T, "key" | TModifiers>;
+    foreignKey<K extends {}>(relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>): SchemaForeignKey<T, TModifiers, K>;
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
     deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
@@ -29,4 +39,18 @@ export declare class SchemaString<T extends string, TModifiers extends SchemaMod
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    /**
+     * Marks this string as eligible for the collection's full-text search index.
+     *
+     * ```ts
+     * title: s.string().searchable(),
+     * body: s.string({ maxLength: 4000 }).searchable(),
+     * ```
+     *
+     * Nothing is indexed until the collection declares `.searchIndex()`. Combines with
+     * `.optional()` and `.nullable()` in either sense — an absent or null value contributes no
+     * tokens.
+     */
+    searchable(): SchemaSearchable<T, "searchable" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaVector.d.ts

@@ -0,0 +1,61 @@
+import { DefaultValue, SchemaModifiers, SchemaTypes } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "../modifiers/SchemaDefault";
+import { SchemaFrom } from "../modifiers/SchemaFrom";
+import { SchemaNullable } from "../modifiers/SchemaNullable";
+import { SchemaOptional } from "../modifiers/SchemaOptional";
+import { SchemaReadonly } from "../modifiers/SchemaReadonly";
+import { SchemaTag } from "../modifiers/SchemaTag";
+/**
+ * An embedding: a fixed-length list of numbers you can search by similarity.
+ *
+ * ```ts
+ * const documentSchema = s.define('documents', {
+ *     id: s.string().key().identity(),
+ *     title: s.string(),
+ *     embedding: s.vector(1536),
+ * }).compile();
+ *
+ * const similar = await store.documents
+ *     .nearest(x => x.embedding, queryEmbedding, 10)
+ *     .toArrayAsync();
+ * ```
+ *
+ * ## Why this is not `s.array(s.number())`
+ *
+ * By value it is exactly that, and every codegen handler treats the two the same on purpose —
+ * a vector clones with a spread, compares by JSON and freezes like any other array. What an
+ * array cannot carry is the DIMENSION COUNT, and a backend that stores vectors natively needs
+ * it at DDL time: pgvector's column type is `vector(1536)`, not `vector`.
+ *
+ * So this exists to be RECOGNISED, not to behave differently. A backend that knows what a
+ * vector is stores one; every other backend sees a list of numbers and stores JSON, which is
+ * why the feature works everywhere rather than only on PostgreSQL.
+ *
+ * ## Dimensions are not enforced here
+ *
+ * `dimensions` is a declaration, and core never checks a value against it. The check belongs
+ * where the cost of being wrong is paid: a backend with a native `vector(n)` column rejects a
+ * mismatched write itself, with an error naming the column. Validating in core would duplicate
+ * that on the backends that already do it and add a per-save array scan to the ones that
+ * cannot use the information at all.
+ *
+ * ## Similarity is cosine, and it is not a filter
+ *
+ * `.nearest()` is an ordering plus a limit — it returns the closest rows, not the matching
+ * ones. Distance itself is not exposed: the entity shape is fixed, and the ordering is what
+ * callers act on. A backend with no vector support scores in memory, so the answer is the
+ * same everywhere; only the amount of data read differs.
+ */
+export declare class SchemaVector<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaVector;
+    constructor(dimensions: number);
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
+}

package/dist/schema/property/types/index.d.ts

@@ -4,3 +4,5 @@ export * from './SchemaDate';
 export * from './SchemaNumber';
 export * from './SchemaObject';
 export * from './SchemaString';
+export * from './SchemaFile';
+export * from './SchemaVector';

package/dist/schema/table/SchemaTransform.d.ts

@@ -0,0 +1,40 @@
+import { SchemaBase } from "../property/base/SchemaBase";
+import { PropertyTransform, SchemaModifiers } from "../types";
+/**
+ * A two-way transform between the value your application holds and the value that is stored.
+ *
+ * Declared in `.modify()`, beside `computed` and `function`, because it belongs to the same
+ * family: a property whose stored form is derived rather than assigned. `computed` derives one
+ * way and cannot come back; a transform declares both directions.
+ *
+ * ```ts
+ * const cipher = myEncryption(keyring);   // whatever you use — {} with `to` and `from`
+ *
+ * const userSchema = s.define('users', {
+ *     id: s.string().key().identity(),
+ *     ssn: s.string(),
+ * }).modify(x => ({
+ *     ssn: x.transform(cipher),
+ * })).compile();
+ * ```
+ *
+ * `to` and `from` may be async, and they are held as LIVE references — never stringified into
+ * generated code the way `computed` is. So they close over whatever they need, which is why
+ * there is no `injected` argument to pass and no property to repeat.
+ *
+ * Nothing about this is encryption. Encryption is one thing a caller might write here;
+ * compression, redaction, unit conversion and a custom codec are others. The library ships no
+ * behaviour of its own for this — it only carries what you supply.
+ */
+export declare class SchemaTransform<T extends any, TModifiers extends SchemaModifiers = never> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaTransform;
+    /**
+     * Bound to the property it replaces when the schema is assembled.
+     *
+     * You do not pass the property in. `.modify()` already knows which one you mean — it is
+     * the key you assigned to — so repeating `s.string()` would be ceremony for nothing.
+     */
+    bindTo(underlying: SchemaBase<T, TModifiers>): this;
+    constructor(transform: PropertyTransform<T>);
+}

package/dist/schema/table/index.d.ts

@@ -1,2 +1,3 @@
 export * from './SchemaComputed';
 export * from './SchemaFunction';
+export * from './SchemaTransform';