@qlever-llc/trellis 0.7.0 → 0.8.0-rc.2

package/script/npm/src/kv.js

@@ -0,0 +1,480 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TypedKVEntry_value;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedKVEntry = exports.TypedKV = void 0;
+const kv_1 = require("@nats-io/kv");
+const jetstream_1 = require("@nats-io/jetstream");
+const result_1 = require("@qlever-llc/result");
+const value_1 = __importStar(require("typebox/value"));
+const index_js_1 = require("./errors/index.js");
+const helpers_js_1 = require("./helpers.js");
+function externalizeValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(externalizeValue);
+    }
+    if (value !== null && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry !== undefined) {
+                out[key] = externalizeValue(entry);
+            }
+        }
+        return out;
+    }
+    return value;
+}
+function parseExternalValue(schema, value) {
+    if (value_1.default.HasCodec(schema)) {
+        return value_1.default.Decode(schema, value);
+    }
+    return value_1.default.Parse(schema, value);
+}
+function serializeValue(schema, value) {
+    return JSON.stringify(value_1.default.Parse(schema, externalizeValue(value)));
+}
+function serializeExternalValue(schema, value) {
+    return serializeValue(schema, value);
+}
+async function ensureExistingBucketOptions(nats, name, options) {
+    const desiredTtlMs = options.ttl ?? 0;
+    if (desiredTtlMs <= 0)
+        return;
+    const jsm = await (0, jetstream_1.jetstreamManager)(nats);
+    const streamName = `KV_${name}`;
+    const info = await jsm.streams.info(streamName);
+    const desiredMaxAge = desiredTtlMs * 1_000_000;
+    if (info.config.max_age >= desiredMaxAge)
+        return;
+    await jsm.streams.update(info.config.name, {
+        ...info.config,
+        max_age: desiredMaxAge,
+    });
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeUnknown(target, source) {
+    if (!isPlainObject(target) || !isPlainObject(source)) {
+        return source;
+    }
+    const out = { ...target };
+    for (const [key, entry] of Object.entries(source)) {
+        if (entry === undefined)
+            continue;
+        out[key] = mergeUnknown(target[key], entry);
+    }
+    return out;
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function collectFailureText(value, depth = 0) {
+    if (depth > 2)
+        return "";
+    const parts = [];
+    if (value instanceof Error) {
+        parts.push(value.name, value.message);
+        if (value.cause !== undefined) {
+            parts.push(collectFailureText(value.cause, depth + 1));
+        }
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        parts.push(String(value));
+    }
+    const record = asRecord(value);
+    if (record) {
+        for (const key of ["name", "message", "description", "code", "err_code"]) {
+            const field = record[key];
+            if (typeof field === "string" || typeof field === "number") {
+                parts.push(String(field));
+            }
+        }
+        if (record.api_error !== undefined) {
+            parts.push(collectFailureText(record.api_error, depth + 1));
+        }
+        if (record.cause !== undefined) {
+            parts.push(collectFailureText(record.cause, depth + 1));
+        }
+    }
+    return parts.join(" ").toLowerCase();
+}
+function inferKvFailureReason(operation, cause) {
+    const text = collectFailureText(cause);
+    if (text.includes("wrong last sequence") ||
+        text.includes("revision mismatch") ||
+        text.includes("sequence mismatch")) {
+        return operation === "create" ? "exists" : "revision mismatch";
+    }
+    if (operation === "create" &&
+        (text.includes("already exists") || text.includes("key exists"))) {
+        return "exists";
+    }
+    return undefined;
+}
+function kvError(operation, key, cause) {
+    const reason = inferKvFailureReason(operation, cause);
+    return new index_js_1.KVError({
+        operation,
+        cause,
+        context: reason === undefined ? { key } : { key, reason },
+    });
+}
+class TypedKV {
+    constructor(schema, kv) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kv
+        });
+    }
+    static fromParts(schema, kv) {
+        return new TypedKV(schema, kv);
+    }
+    static open(nats, name, schema, options) {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                const kvm = new kv_1.Kvm(nats);
+                const kv = options.bindOnly
+                    ? await kvm.open(name)
+                    : await kvm.create(name, {
+                        history: options.history ?? 1,
+                        ttl: options.ttl ?? 0,
+                        ...(options.replicas !== undefined
+                            ? { replicas: options.replicas }
+                            : {}),
+                        ...(options.maxValueBytes
+                            ? { maxValueSize: options.maxValueBytes }
+                            : {}),
+                    });
+                if (!options.bindOnly) {
+                    await ensureExistingBucketOptions(nats, name, options);
+                }
+                const typedKv = TypedKV.fromParts(schema, kv);
+                return result_1.Result.ok(typedKv);
+            }
+            catch (cause) {
+                return result_1.Result.err(new index_js_1.KVError({ operation: "open", cause }));
+            }
+        })());
+    }
+    get(key) {
+        return result_1.AsyncResult.from((async () => {
+            let s;
+            try {
+                s = await this.kv.get((0, helpers_js_1.escapeKvKey)(key));
+            }
+            catch (cause) {
+                return result_1.Result.err(new index_js_1.KVError({ operation: "get", cause, context: { key } }));
+            }
+            if (!s) {
+                return result_1.Result.err(new index_js_1.KVError({
+                    operation: "get",
+                    context: { key, reason: "not found" },
+                }));
+            }
+            const result = await createTypedKvEntry(this.schema, this.kv, s);
+            return result;
+        })());
+    }
+    serialize(value) {
+        return serializeExternalValue(this.schema, value);
+    }
+    create(key, value) {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                await this.kv.create((0, helpers_js_1.escapeKvKey)(key), this.serialize(value));
+                return result_1.Result.ok(undefined);
+            }
+            catch (cause) {
+                return result_1.Result.err(kvError("create", key, cause));
+            }
+        })());
+    }
+    put(key, value) {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                await this.kv.put((0, helpers_js_1.escapeKvKey)(key), this.serialize(value));
+                return result_1.Result.ok(undefined);
+            }
+            catch (cause) {
+                return result_1.Result.err(kvError("put", key, cause));
+            }
+        })());
+    }
+    delete(key) {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                await this.kv.delete((0, helpers_js_1.escapeKvKey)(key));
+                return result_1.Result.ok(undefined);
+            }
+            catch (cause) {
+                return result_1.Result.err(kvError("delete", key, cause));
+            }
+        })());
+    }
+    keys(filter = ">") {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                return result_1.Result.ok(await this.kv.keys(filter));
+            }
+            catch (cause) {
+                return result_1.Result.err(new index_js_1.KVError({ operation: "keys", cause, context: { filter } }));
+            }
+        })());
+    }
+    status() {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                const status = await this.kv.status();
+                return result_1.Result.ok({ values: status.values });
+            }
+            catch (cause) {
+                return result_1.Result.err(new index_js_1.KVError({ operation: "status", cause }));
+            }
+        })());
+    }
+}
+exports.TypedKV = TypedKV;
+class TypedKVEntry {
+    constructor(schema, kv, entry, value) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kv
+        });
+        Object.defineProperty(this, "entry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: entry
+        });
+        _TypedKVEntry_value.set(this, void 0);
+        __classPrivateFieldSet(this, _TypedKVEntry_value, value, "f");
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _TypedKVEntry_value, "f");
+    }
+    static create(schema, kv, entry) {
+        return result_1.AsyncResult.from((async () => {
+            const result = await createTypedKvEntry(schema, kv, entry);
+            return result;
+        })());
+    }
+    get key() {
+        return (0, helpers_js_1.decodeSubject)(this.entry.key);
+    }
+    get revision() {
+        return this.entry.revision;
+    }
+    get createdAt() {
+        return this.entry.created;
+    }
+    /**
+     * Watch this KV entry for changes.
+     *
+     * @param callback - Function called when the entry changes
+     * @param opts - Watch options (e.g., includeDeletes)
+     * @returns A function to stop watching
+     */
+    async watch(callback, opts) {
+        const watcher = await this.kv.watch({
+            key: this.entry.key,
+            include: opts?.includeDeletes ? "history" : "updates",
+        });
+        const abortController = new AbortController();
+        // Start the async iteration in the background
+        (async () => {
+            for await (const entry of watcher) {
+                if (abortController.signal.aborted)
+                    break;
+                if (entry.operation === "DEL" || entry.operation === "PURGE") {
+                    if (opts?.includeDeletes) {
+                        callback({
+                            type: "delete",
+                            key: (0, helpers_js_1.decodeSubject)(entry.key),
+                            revision: entry.revision,
+                            timestamp: entry.created,
+                        });
+                    }
+                }
+                else {
+                    try {
+                        const json = entry.json();
+                        const validated = parseExternalValue(this.schema, json);
+                        callback({
+                            type: "update",
+                            key: (0, helpers_js_1.decodeSubject)(entry.key),
+                            value: validated,
+                            revision: entry.revision,
+                            timestamp: entry.created,
+                        });
+                    }
+                    catch (cause) {
+                        callback({
+                            type: "error",
+                            key: (0, helpers_js_1.decodeSubject)(entry.key),
+                            error: createValidationError(this.schema, entry, cause),
+                            revision: entry.revision,
+                            timestamp: entry.created,
+                        });
+                    }
+                }
+            }
+        })();
+        return () => {
+            abortController.abort();
+            watcher.stop();
+        };
+    }
+    merge(value, vcc) {
+        const mergedData = mergeUnknown(__classPrivateFieldGet(this, _TypedKVEntry_value, "f"), value);
+        const mergeResult = result_1.Result.try(() => serializeExternalValue(this.schema, mergedData));
+        if (mergeResult.isErr()) {
+            const cause = mergeResult.error.cause;
+            if (cause instanceof value_1.ParseError) {
+                const errors = value_1.default.Errors(this.schema, externalizeValue(mergedData));
+                return result_1.AsyncResult.err(new index_js_1.ValidationError({ errors, cause }));
+            }
+            return result_1.AsyncResult.err(new index_js_1.KVError({
+                operation: "merge",
+                cause: mergeResult.error,
+                context: { key: this.key },
+            }));
+        }
+        return this.put(mergedData, vcc);
+    }
+    put(value, vcc) {
+        return result_1.AsyncResult.from((async () => {
+            const serialized = serializeValue(this.schema, value);
+            try {
+                await this.kv.put(this.entry.key, serialized, {
+                    previousSeq: vcc ? this.entry.revision : undefined,
+                });
+                return result_1.Result.ok(undefined);
+            }
+            catch (cause) {
+                return result_1.Result.err(kvError("put", this.key, cause));
+            }
+        })());
+    }
+    delete(vcc) {
+        return result_1.AsyncResult.from((async () => {
+            try {
+                await this.kv.delete(this.entry.key, {
+                    previousSeq: vcc ? this.entry.revision : undefined,
+                });
+                return result_1.Result.ok(undefined);
+            }
+            catch (cause) {
+                return result_1.Result.err(kvError("delete", this.key, cause));
+            }
+        })());
+    }
+}
+exports.TypedKVEntry = TypedKVEntry;
+_TypedKVEntry_value = new WeakMap();
+async function createTypedKvEntry(schema, kv, entry) {
+    const jsonResult = result_1.Result.try(() => entry.json());
+    if (jsonResult.isErr()) {
+        return result_1.Result.err(createValidationError(schema, entry, jsonResult.error));
+    }
+    const json = jsonResult.take();
+    const parseResult = result_1.Result.try(() => {
+        if (value_1.default.HasCodec(schema)) {
+            return value_1.default.Decode(schema, json);
+        }
+        return value_1.default.Parse(schema, json);
+    });
+    if (parseResult.isErr()) {
+        return result_1.Result.err(createValidationError(schema, entry, parseResult.error, json));
+    }
+    const typedEntry = new TypedKVEntry(schema, kv, entry, parseResult.take());
+    return result_1.Result.ok(typedEntry);
+}
+function createValidationError(schema, entry, cause, json) {
+    if (cause instanceof value_1.ParseError) {
+        return new index_js_1.ValidationError({
+            errors: value_1.default.Errors(schema, json),
+            cause,
+            context: {
+                key: (0, helpers_js_1.decodeSubject)(entry.key),
+                revision: entry.revision,
+            },
+        });
+    }
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    return new index_js_1.ValidationError({
+        errors: [{
+                path: "",
+                message: `Failed to decode KV value: ${error.message}`,
+            }],
+        cause: error,
+        context: {
+            key: (0, helpers_js_1.decodeSubject)(entry.key),
+            revision: entry.revision,
+        },
+    });
+}

package/script/npm/src/models/auth/rpc/Logout.d.ts

@@ -0,0 +1,8 @@
+import Type, { type Static } from "typebox";
+export declare const AuthLogoutSchema: Type.TObject<{}>;
+export type AuthLogoutInput = Static<typeof AuthLogoutSchema>;
+export declare const AuthLogoutResponseSchema: Type.TObject<{
+    success: Type.TBoolean;
+}>;
+export type AuthLogoutResponse = Static<typeof AuthLogoutResponseSchema>;
+//# sourceMappingURL=Logout.d.ts.map

package/script/npm/src/models/auth/rpc/Logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logout.d.ts","sourceRoot":"","sources":["../../../../../../src/models/auth/rpc/Logout.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,gBAAgB,kBAE5B,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE9D,eAAO,MAAM,wBAAwB;;EAIpC,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/script/npm/src/models/auth/rpc/Logout.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthLogoutResponseSchema = exports.AuthLogoutSchema = void 0;
+const typebox_1 = __importDefault(require("typebox"));
+exports.AuthLogoutSchema = typebox_1.default.Object({});
+exports.AuthLogoutResponseSchema = typebox_1.default.Object({
+    success: typebox_1.default.Boolean(),
+});

package/script/npm/src/models/trellis/Paginate.d.ts

@@ -0,0 +1,7 @@
+import Type, { type StaticDecode } from "typebox";
+export declare const PaginateSchema: Type.TObject<{
+    offset: Type.TInteger;
+    limit: Type.TInteger;
+}>;
+export type Paginate = StaticDecode<typeof PaginateSchema>;
+//# sourceMappingURL=Paginate.d.ts.map

package/script/npm/src/models/trellis/Paginate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Paginate.d.ts","sourceRoot":"","sources":["../../../../../src/models/trellis/Paginate.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,cAAc;;;EAGzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/script/npm/src/models/trellis/Paginate.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginateSchema = void 0;
+const typebox_1 = __importDefault(require("typebox"));
+exports.PaginateSchema = typebox_1.default.Object({
+    offset: typebox_1.default.Integer({ minimum: 0, default: 0 }),
+    limit: typebox_1.default.Integer({ minimum: 0, default: 10 }),
+});

package/script/npm/src/models/trellis/State.d.ts

@@ -0,0 +1,48 @@
+import Type, { type StaticDecode } from "typebox";
+import type { JsonValue as TrellisJsonValue } from "../../contracts.js";
+export declare const StateStoreKindSchema: Type.TUnion<[Type.TLiteral<"value">, Type.TLiteral<"map">]>;
+export type StateStoreKind = "value" | "map";
+export declare const StateScopeSchema: Type.TUnion<[Type.TLiteral<"userApp">, Type.TLiteral<"deviceApp">]>;
+export type StateScope = "userApp" | "deviceApp";
+export declare const JsonValueSchema: Type.TUnknown;
+export type JsonValue = TrellisJsonValue;
+export declare const StateEntrySchema: Type.TObject<{
+    key: Type.TOptional<Type.TString>;
+    value: Type.TUnknown;
+    revision: Type.TString;
+    updatedAt: Type.TString;
+    expiresAt: Type.TOptional<Type.TString>;
+}>;
+export type StateEntry = {
+    key?: string;
+    value: TrellisJsonValue;
+    revision: string;
+    updatedAt: string;
+    expiresAt?: string;
+};
+export declare const StateMigrationRequiredSchema: Type.TObject<{
+    migrationRequired: Type.TLiteral<true>;
+    entry: Type.TObject<{
+        key: Type.TOptional<Type.TString>;
+        value: Type.TUnknown;
+        revision: Type.TString;
+        updatedAt: Type.TString;
+        expiresAt: Type.TOptional<Type.TString>;
+    }>;
+    stateVersion: Type.TString;
+    currentStateVersion: Type.TString;
+    writerContractDigest: Type.TString;
+}>;
+export type StateMigrationRequired = {
+    migrationRequired: true;
+    entry: StateEntry;
+    stateVersion: string;
+    currentStateVersion: string;
+    writerContractDigest: string;
+};
+export declare const StateUserTargetSchema: Type.TObject<{
+    origin: Type.TString;
+    id: Type.TString;
+}>;
+export type StateUserTarget = StaticDecode<typeof StateUserTargetSchema>;
+//# sourceMappingURL=State.d.ts.map

package/script/npm/src/models/trellis/State.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../../../src/models/trellis/State.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAExE,eAAO,MAAM,oBAAoB,6DAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,CAAC;AAE7C,eAAO,MAAM,gBAAgB,qEAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC;AAEjD,eAAO,MAAM,eAAe,eAAiB,CAAC;AAC9C,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC;AAEzC,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAMvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,IAAI,CAAC;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;EAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/script/npm/src/models/trellis/State.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateUserTargetSchema = exports.StateMigrationRequiredSchema = exports.StateEntrySchema = exports.JsonValueSchema = exports.StateScopeSchema = exports.StateStoreKindSchema = void 0;
+const typebox_1 = __importDefault(require("typebox"));
+exports.StateStoreKindSchema = typebox_1.default.Union([
+    typebox_1.default.Literal("value"),
+    typebox_1.default.Literal("map"),
+]);
+exports.StateScopeSchema = typebox_1.default.Union([
+    typebox_1.default.Literal("userApp"),
+    typebox_1.default.Literal("deviceApp"),
+]);
+exports.JsonValueSchema = typebox_1.default.Unknown();
+exports.StateEntrySchema = typebox_1.default.Object({
+    key: typebox_1.default.Optional(typebox_1.default.String({ minLength: 1 })),
+    value: exports.JsonValueSchema,
+    revision: typebox_1.default.String({ minLength: 1 }),
+    updatedAt: typebox_1.default.String({ format: "date-time" }),
+    expiresAt: typebox_1.default.Optional(typebox_1.default.String({ format: "date-time" })),
+});
+exports.StateMigrationRequiredSchema = typebox_1.default.Object({
+    migrationRequired: typebox_1.default.Literal(true),
+    entry: exports.StateEntrySchema,
+    stateVersion: typebox_1.default.String({ minLength: 1 }),
+    currentStateVersion: typebox_1.default.String({ minLength: 1 }),
+    writerContractDigest: typebox_1.default.String({ minLength: 1 }),
+});
+exports.StateUserTargetSchema = typebox_1.default.Object({
+    origin: typebox_1.default.String({ minLength: 1 }),
+    id: typebox_1.default.String({ minLength: 1 }),
+});

package/script/npm/src/models/trellis/TrellisError.d.ts

@@ -0,0 +1,20 @@
+import Type, { type StaticDecode } from "typebox";
+/**
+ * Open transport schema for Trellis RPC error payloads.
+ *
+ * Error payloads must always carry the base error fields, but service-local contract
+ * errors may add arbitrary additional properties. The client validates declared local
+ * errors against their contract schema before reconstructing runtime `Error` instances.
+ */
+export declare const TrellisErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TString;
+    message: Type.TString;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+/**
+ * Type for validated transport error data.
+ */
+export type TrellisErrorData = StaticDecode<typeof TrellisErrorDataSchema>;
+//# sourceMappingURL=TrellisError.d.ts.map

package/script/npm/src/models/trellis/TrellisError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrellisError.d.ts","sourceRoot":"","sources":["../../../../../src/models/trellis/TrellisError.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;EAMD,CAAC;AAEnC;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/script/npm/src/models/trellis/rpc/StateDelete.d.ts

@@ -0,0 +1,12 @@
+import Type, { type Static } from "typebox";
+export declare const StateDeleteSchema: Type.TObject<{
+    store: Type.TString;
+    key: Type.TOptional<Type.TString>;
+    expectedRevision: Type.TOptional<Type.TString>;
+}>;
+export type StateDeleteInput = Static<typeof StateDeleteSchema>;
+export declare const StateDeleteResponseSchema: Type.TObject<{
+    deleted: Type.TBoolean;
+}>;
+export type StateDeleteResponse = Static<typeof StateDeleteResponseSchema>;
+//# sourceMappingURL=StateDelete.d.ts.map

package/script/npm/src/models/trellis/rpc/StateDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateDelete.d.ts","sourceRoot":"","sources":["../../../../../../src/models/trellis/rpc/StateDelete.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEhE,eAAO,MAAM,yBAAyB;;EAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/script/npm/src/models/trellis/rpc/StateDelete.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateDeleteResponseSchema = exports.StateDeleteSchema = void 0;
+const typebox_1 = __importDefault(require("typebox"));
+exports.StateDeleteSchema = typebox_1.default.Object({
+    store: typebox_1.default.String({ minLength: 1 }),
+    key: typebox_1.default.Optional(typebox_1.default.String({ minLength: 1 })),
+    expectedRevision: typebox_1.default.Optional(typebox_1.default.String({ minLength: 1 })),
+});
+exports.StateDeleteResponseSchema = typebox_1.default.Object({
+    deleted: typebox_1.default.Boolean(),
+});