@atscript/typescript 0.1.83 → 0.1.84

package/dist/cli.cjs

@@ -2623,9 +2623,16 @@ const PLAN_HEADER = [
 	DYE_COLORS.bold("╚══════════════════════════════════════╝"),
 	""
 ];
+function planFlags(plan) {
+	return {
+		destructive: plan.entries.some((e) => e.destructive),
+		hasChanges: plan.entries.some((e) => e.hasChanges),
+		hasErrors: plan.entries.some((e) => e.hasErrors)
+	};
+}
 var DbSyncPrinter = class {
 	log(...args) {
-		console.log(...args);
+		if (!this.muted) console.log(...args);
 	}
 	banner() {
 		this.log(BANNER);
@@ -2650,6 +2657,60 @@ var DbSyncPrinter = class {
 		this.printGrouped(result.entries, "result");
 		this.log("");
 	}
+	/** Renders the plan as a JSON document for CI consumption. */ renderJson(plan) {
+		const doc = {
+			status: plan.status,
+			schemaHash: plan.schemaHash,
+			...planFlags(plan),
+			entries: plan.entries.map((e) => ({
+				name: e.name,
+				kind: e.viewType ? "view" : "table",
+				viewType: e.viewType,
+				status: e.status,
+				destructive: e.destructive,
+				syncMethod: e.syncMethod,
+				renamedFrom: e.renamedFrom,
+				columnsToAdd: e.columnsToAdd.map((c) => ({
+					path: c.path,
+					physicalName: c.physicalName,
+					designType: c.designType,
+					optional: c.optional,
+					isPrimaryKey: c.isPrimaryKey,
+					storage: c.storage
+				})),
+				columnsToRename: e.columnsToRename,
+				typeChanges: e.typeChanges,
+				nullableChanges: e.nullableChanges,
+				defaultChanges: e.defaultChanges,
+				columnsToDrop: e.columnsToDrop,
+				optionChanges: e.optionChanges,
+				fkAdded: e.fkAdded,
+				fkRemoved: e.fkRemoved,
+				fkChanged: e.fkChanged,
+				errors: e.errors
+			}))
+		};
+		return `${JSON.stringify(doc, undefined, 2)}\n`;
+	}
+	/** Renders the plan as a Markdown document (e.g. for PR comments). */ renderMarkdown(plan) {
+		const { destructive } = planFlags(plan);
+		const lines = [
+			"# Schema Sync Plan",
+			"",
+			`- **Status:** ${plan.status}${destructive ? " (destructive)" : ""}`,
+			`- **Schema hash:** \`${plan.schemaHash}\``,
+			""
+		];
+		const tables = plan.entries.filter((e) => !e.viewType);
+		const views = plan.entries.filter((e) => e.viewType);
+		for (const [title, entries] of [["Tables", tables], ["Views", views]]) {
+			if (entries.length === 0) continue;
+			lines.push(`## ${title}`, "", "```");
+			for (const e of entries) for (const line of e.print("plan")) lines.push(line);
+			lines.push("```", "");
+		}
+		return `${lines.join("\n")}\n`;
+	}
 	printGrouped(entries, mode) {
 		const tables = entries.filter((e) => !e.viewType);
 		const views = entries.filter((e) => e.viewType);
@@ -2665,6 +2726,7 @@ var DbSyncPrinter = class {
 	}
 	constructor() {
 		_define_property$1(this, "colors", DYE_COLORS);
+		/** When true, all pretty-print output is suppressed (structured stdout mode). */ _define_property$1(this, "muted", false);
 	}
 };
 
@@ -2695,15 +2757,25 @@ function _ts_param(paramIndex, decorator) {
 	};
 }
 var DbSyncController = class {
-	async dbSync(configFile, dryRun, yes, force, safe) {
-		const config = await getConfig(configFile, this.logger);
+	info(message) {
+		if (!this.quiet) this.logger.log(message);
+	}
+	async dbSync(configFile, dryRun, yes, force, safe, check, format, out) {
+		if (format && format !== "json" && format !== "markdown") {
+			this.logger.error(`${"\x1B[31m"}Unknown --format "${format}". Use "json" or "markdown".${"\x1B[39m"}`);
+			process.exit(1);
+		}
+		this.quiet = Boolean(format) && !out;
+		this.printer.muted = this.quiet;
+		const cfgLogger = this.quiet ? Object.create(this.logger, { log: { value: () => {} } }) : this.logger;
+		const config = await getConfig(configFile, cfgLogger);
 		if (!config.db) {
 			this.logger.error(`${"\x1B[31m"}No "db" field in atscript config. ` + `Add a db configuration to use schema sync.${"\x1B[39m"}`);
 			process.exit(1);
 		}
 		const [dbSpace, dbTypes] = await Promise.all([this.resolveDbSpace(config.db), this.compileAndLoadTypes(config)]);
 		if (dbTypes.length === 0) {
-			this.logger.log(`No types with @db.table or @db.view found. Nothing to sync.`);
+			this.info(`No types with @db.table or @db.view found. Nothing to sync.`);
 			return;
 		}
 		this.printer.typeCount(dbTypes.length);
@@ -2714,18 +2786,30 @@ var DbSyncController = class {
 			force,
 			safe
 		});
-		if (plan.status === "up-to-date") {
-			this.printer.planUpToDate(plan);
-			return;
+		const { destructive: hasDestructive, hasChanges, hasErrors } = planFlags(plan);
+		if (format) {
+			const doc = format === "json" ? this.printer.renderJson(plan) : this.printer.renderMarkdown(plan);
+			if (out) {
+				(0, fs.writeFileSync)(out, doc);
+				this.info(`Plan written to ${out}`);
+			} else process.stdout.write(doc);
+		}
+		if (plan.status === "up-to-date") this.printer.planUpToDate(plan);
+else {
+			this.printer.plan(plan);
+			if (hasErrors) {
+				this.logger.error(`Schema has errors. Fix the issues above before syncing.`);
+				process.exit(1);
+			}
 		}
-		const hasDestructive = plan.entries.some((e) => e.destructive);
-		const hasChanges = plan.entries.some((e) => e.hasChanges);
-		const hasErrors = plan.entries.some((e) => e.hasErrors);
-		this.printer.plan(plan);
-		if (hasErrors) {
-			this.logger.error(`Schema has errors. Fix the issues above before syncing.`);
-			process.exit(1);
+		if (check || format) {
+			if (check && hasChanges) {
+				this.logger.error(hasDestructive ? `Schema changes needed (includes destructive operations).` : `Schema changes needed.`);
+				process.exit(hasDestructive ? 2 : 1);
+			}
+			return;
 		}
+		if (plan.status === "up-to-date") return;
 		if (!hasChanges) {
 			if (!dryRun) await sync.run(dbTypes, {
 				force: true,
@@ -2760,7 +2844,7 @@ var DbSyncController = class {
 			if (dbConfig.exclude) buildConfig.exclude = dbConfig.exclude;
 		}
 		buildConfig.format = "js";
-		this.logger.log(`Compiling .as files...`);
+		this.info(`Compiling .as files...`);
 		const builder = await (0, __atscript_core.build)(buildConfig);
 		const outputs = await builder.generate(buildConfig);
 		const jsOutputs = outputs.filter((o) => o.fileName.endsWith(".js"));
@@ -2795,11 +2879,11 @@ var DbSyncController = class {
 	}
 	async resolveDbSpace(dbConfig) {
 		if (typeof dbConfig === "function") {
-			this.logger.log(`Resolving database space from callback...`);
+			this.info(`Resolving database space from callback...`);
 			return await dbConfig();
 		}
 		const { adapter, connection, options } = dbConfig;
-		this.logger.log(`Using adapter: ${"\x1B[36m"}${adapter}${"\x1B[39m"}`);
+		this.info(`Using adapter: ${"\x1B[36m"}${adapter}${"\x1B[39m"}`);
 		let mod;
 		try {
 			mod = await this.importFromCwd(adapter);
@@ -2841,7 +2925,9 @@ var DbSyncController = class {
 	constructor(logger) {
 		_define_property(this, "logger", void 0);
 		_define_property(this, "printer", void 0);
+		/** Muted when structured --format output goes to stdout, to keep it parseable. */ _define_property(this, "quiet", void 0);
 		this.logger = logger;
+		this.quiet = false;
 		this.printer = new DbSyncPrinter();
 	}
 };
@@ -2853,6 +2939,9 @@ _ts_decorate([
 	(0, __moostjs_event_cli.CliExample)("db sync --yes", "Skip confirmation prompt (CI mode)"),
 	(0, __moostjs_event_cli.CliExample)("db sync --force", "Re-sync even if schema hash matches"),
 	(0, __moostjs_event_cli.CliExample)("db sync --safe", "Skip destructive operations (column/table drops)"),
+	(0, __moostjs_event_cli.CliExample)("db sync --check", "Exit 1 when changes are needed, 2 when destructive (CI gate)"),
+	(0, __moostjs_event_cli.CliExample)("db sync --format json", "Emit the plan as JSON to stdout, do not apply"),
+	(0, __moostjs_event_cli.CliExample)("db sync --format markdown --out plan.md", "Write the plan as Markdown to a file"),
 	_ts_param(0, (0, __moostjs_event_cli.CliOption)("c", "config")),
 	_ts_param(0, (0, moost.Optional)()),
 	_ts_param(0, (0, moost.Description)("Path to config file")),
@@ -2868,13 +2957,25 @@ _ts_decorate([
 	_ts_param(4, (0, __moostjs_event_cli.CliOption)("safe")),
 	_ts_param(4, (0, moost.Optional)()),
 	_ts_param(4, (0, moost.Description)("Skip destructive operations (column/table drops)")),
+	_ts_param(5, (0, __moostjs_event_cli.CliOption)("check")),
+	_ts_param(5, (0, moost.Optional)()),
+	_ts_param(5, (0, moost.Description)("Plan only; exit 1 when changes are needed, 2 when destructive changes are present")),
+	_ts_param(6, (0, __moostjs_event_cli.CliOption)("f", "format")),
+	_ts_param(6, (0, moost.Optional)()),
+	_ts_param(6, (0, moost.Description)("Emit the plan as \"json\" or \"markdown\" instead of applying (plan-only mode)")),
+	_ts_param(7, (0, __moostjs_event_cli.CliOption)("out")),
+	_ts_param(7, (0, moost.Optional)()),
+	_ts_param(7, (0, moost.Description)("Write --format output to a file instead of stdout")),
 	_ts_metadata("design:type", Function),
 	_ts_metadata("design:paramtypes", [
 		String,
 		Boolean,
 		Boolean,
 		Boolean,
-		Boolean
+		Boolean,
+		Boolean,
+		String,
+		String
 	]),
 	_ts_metadata("design:returntype", Promise)
 ], DbSyncController.prototype, "dbSync", null);

package/dist/utils.cjs

@@ -1,6 +1,133 @@
 "use strict";
 const require_json_schema = require('./json-schema-3mti4G4J.cjs');
 
+//#region packages/typescript/src/runtime/coerce.ts
+/**
+* Internal sentinel returned when a value cannot be coerced to a type node.
+* Drives union branch selection without allocating per-node result objects.
+*/ const NO_MATCH = Symbol("atscript.coerce.no-match");
+function coerceForType(def, value) {
+	const result = coerce(def, value);
+	return result === NO_MATCH ? value : result;
+}
+function coerceScalar(designType, value) {
+	const result = scalar(designType, value);
+	return result === NO_MATCH ? value : result;
+}
+/** Returns the coerced value, or NO_MATCH when the value can't fit this node. */ function coerce(def, value) {
+	if (value === undefined || value === null) return def.optional === true ? value : NO_MATCH;
+	return require_json_schema.forAnnotatedType(def, {
+		final: (d) => {
+			const result = scalar(d.type.designType, value);
+			if (result !== NO_MATCH && d.type.value !== undefined && result !== d.type.value) return NO_MATCH;
+			return result;
+		},
+		phantom: () => value,
+		object: (d) => {
+			if (!isPlainObject(value)) return NO_MATCH;
+			return coerceProps(d, value);
+		},
+		array: (d) => Array.isArray(value) ? coerceItems(value, d.type.of) : NO_MATCH,
+		tuple: (d) => Array.isArray(value) && value.length === d.type.items.length ? coerceItems(value, undefined, d.type.items) : NO_MATCH,
+		union: (d) => {
+			for (const item of d.type.items) {
+				const result = coerce(item, value);
+				if (result !== NO_MATCH) return result;
+			}
+			return NO_MATCH;
+		},
+		intersection: (d) => {
+			let current = value;
+			for (const item of d.type.items) {
+				const result = coerce(item, current);
+				if (result === NO_MATCH) return NO_MATCH;
+				current = result;
+			}
+			return current;
+		}
+	});
+}
+function scalar(designType, value) {
+	switch (designType) {
+		case "string":
+		case "decimal": return typeof value === "string" ? value : NO_MATCH;
+		case "number": {
+			if (typeof value === "number") return value;
+			if (typeof value === "string") {
+				const trimmed = value.trim();
+				if (trimmed.length > 0) {
+					const parsed = Number(trimmed);
+					if (Number.isFinite(parsed)) return parsed;
+				}
+			}
+			return NO_MATCH;
+		}
+		case "boolean": {
+			if (typeof value === "boolean") return value;
+			if (value === "true" || value === "1") return true;
+			if (value === "false" || value === "0") return false;
+			return NO_MATCH;
+		}
+		case "object": return typeof value === "object" ? value : NO_MATCH;
+		case "any":
+		case "phantom": return value;
+		default: return NO_MATCH;
+	}
+}
+/**
+* Coerces the props of a plain object. Copy-on-first-change: allocates the
+* output object only when some prop actually coerced, else returns the input.
+*/ function coerceProps(def, value) {
+	const keys = Object.keys(value);
+	let out;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const input = value[key];
+		let propDef = def.type.props.get(key);
+		if (!propDef) {
+			for (const { pattern, def: patternDef } of def.type.propsPatterns) if (pattern.test(key)) {
+				propDef = patternDef;
+				break;
+			}
+		}
+		let coerced = input;
+		if (propDef) {
+			const result = coerce(propDef, input);
+			if (result !== NO_MATCH) coerced = result;
+		}
+		if (out) out[key] = coerced;
+else if (coerced !== input) {
+			out = {};
+			for (let j = 0; j < i; j++) out[keys[j]] = value[keys[j]];
+			out[key] = coerced;
+		}
+	}
+	return out ?? value;
+}
+/**
+* Coerces array/tuple items against `of` (arrays) or `items[i]` (tuples).
+* Copy-on-first-change, same as {@link coerceProps}.
+*/ function coerceItems(value, of, items) {
+	let out;
+	for (let i = 0; i < value.length; i++) {
+		const input = value[i];
+		const result = coerce(of ?? items[i], input);
+		const coerced = result === NO_MATCH ? input : result;
+		if (out) out.push(coerced);
+else if (coerced !== input) {
+			out = value.slice(0, i);
+			out.push(coerced);
+		}
+	}
+	return out ?? value;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+
+//#endregion
 //#region packages/typescript/src/runtime/default-value.ts
 /**
 * Attempts to resolve a value from the mode for the given annotated type.
@@ -487,6 +614,8 @@ exports.ValidatorError = require_json_schema.ValidatorError
 exports.annotate = require_json_schema.annotate
 exports.buildJsonSchema = require_json_schema.buildJsonSchema
 exports.cloneRefProp = require_json_schema.cloneRefProp
+exports.coerceForType = coerceForType
+exports.coerceScalar = coerceScalar
 exports.createAnnotatedTypeNode = require_json_schema.createAnnotatedTypeNode
 exports.createDataFromAnnotatedType = createDataFromAnnotatedType
 exports.defineAnnotatedType = require_json_schema.defineAnnotatedType

package/dist/utils.d.ts

@@ -290,6 +290,39 @@ declare function isPhantomType(def: TAtscriptAnnotatedType): boolean;
  */
 declare function isAnnotatedTypeOfPrimitive(t: TAtscriptAnnotatedType): boolean;
 
+/**
+ * Coerces string-transport input (route params, query strings) toward the
+ * scalar shapes an annotated type expects.
+ *
+ * Pure and non-throwing: when a value can't be coerced it is returned
+ * untouched, leaving the {@link Validator} to report the proper error.
+ * Coercion converts representation only — constraint checks (`@expect.int`,
+ * `@expect.min`, patterns) remain the validator's job.
+ *
+ * Rules:
+ * - Strings targeting `number` are trimmed and parsed via `Number()`; only
+ *   finite results are accepted.
+ * - Strings targeting `boolean` accept `"true"/"1"` and `"false"/"0"`.
+ * - Unions try each branch in declared order; the first successful parse wins.
+ * - Objects recurse into props when the input is a plain object (covers
+ *   `@Query()` DTOs where every field arrives as a string).
+ * - Arrays and tuples coerce items; intersections apply each member in order.
+ * - `string` / `decimal` targets never change string input.
+ *
+ * @example
+ * ```ts
+ * coerceForType(KafkaOffset, '42') // → 42
+ * coerceForType(KafkaOffset, 'abc') // → 'abc' (validator reports the error)
+ * ```
+ */
+declare function coerceForType(def: TAtscriptAnnotatedType, value: unknown): unknown;
+/**
+ * Coerces a single scalar value toward a design type, using the same rules
+ * as {@link coerceForType}. Returns the input untouched when it can't coerce.
+ * Useful when only a design type is known (e.g. `design:paramtypes` fallbacks).
+ */
+declare function coerceScalar(designType: TAtscriptTypeFinal['designType'], value: unknown): unknown;
+
 /** A JSON Schema object (draft-compatible). */
 type TJsonSchema = Record<string, any>;
 /**
@@ -649,5 +682,5 @@ type NavPropsOf<T> = T extends {
     __navProps: infer N extends Record<string, unknown>;
 } ? N : Record<string, never>;
 
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, detectDiscriminator, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, coerceForType, coerceScalar, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, detectDiscriminator, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
 export type { AtscriptQueryComparison, AtscriptQueryFieldRef, AtscriptQueryNode, AtscriptRef, FlatOf, InferDataType, NavPropsOf, OwnPropsOf, PrimaryKeyOf, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptDataType, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TCreateDataOptions, TFlattenOptions, TJsonSchema, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TUnionDiscriminator, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext, TValueResolver };

package/dist/utils.mjs

@@ -1,5 +1,132 @@
 import { Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, defineAnnotatedType, detectDiscriminator, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas } from "./json-schema-B64qclVa.mjs";
 
+//#region packages/typescript/src/runtime/coerce.ts
+/**
+* Internal sentinel returned when a value cannot be coerced to a type node.
+* Drives union branch selection without allocating per-node result objects.
+*/ const NO_MATCH = Symbol("atscript.coerce.no-match");
+function coerceForType(def, value) {
+	const result = coerce(def, value);
+	return result === NO_MATCH ? value : result;
+}
+function coerceScalar(designType, value) {
+	const result = scalar(designType, value);
+	return result === NO_MATCH ? value : result;
+}
+/** Returns the coerced value, or NO_MATCH when the value can't fit this node. */ function coerce(def, value) {
+	if (value === undefined || value === null) return def.optional === true ? value : NO_MATCH;
+	return forAnnotatedType(def, {
+		final: (d) => {
+			const result = scalar(d.type.designType, value);
+			if (result !== NO_MATCH && d.type.value !== undefined && result !== d.type.value) return NO_MATCH;
+			return result;
+		},
+		phantom: () => value,
+		object: (d) => {
+			if (!isPlainObject(value)) return NO_MATCH;
+			return coerceProps(d, value);
+		},
+		array: (d) => Array.isArray(value) ? coerceItems(value, d.type.of) : NO_MATCH,
+		tuple: (d) => Array.isArray(value) && value.length === d.type.items.length ? coerceItems(value, undefined, d.type.items) : NO_MATCH,
+		union: (d) => {
+			for (const item of d.type.items) {
+				const result = coerce(item, value);
+				if (result !== NO_MATCH) return result;
+			}
+			return NO_MATCH;
+		},
+		intersection: (d) => {
+			let current = value;
+			for (const item of d.type.items) {
+				const result = coerce(item, current);
+				if (result === NO_MATCH) return NO_MATCH;
+				current = result;
+			}
+			return current;
+		}
+	});
+}
+function scalar(designType, value) {
+	switch (designType) {
+		case "string":
+		case "decimal": return typeof value === "string" ? value : NO_MATCH;
+		case "number": {
+			if (typeof value === "number") return value;
+			if (typeof value === "string") {
+				const trimmed = value.trim();
+				if (trimmed.length > 0) {
+					const parsed = Number(trimmed);
+					if (Number.isFinite(parsed)) return parsed;
+				}
+			}
+			return NO_MATCH;
+		}
+		case "boolean": {
+			if (typeof value === "boolean") return value;
+			if (value === "true" || value === "1") return true;
+			if (value === "false" || value === "0") return false;
+			return NO_MATCH;
+		}
+		case "object": return typeof value === "object" ? value : NO_MATCH;
+		case "any":
+		case "phantom": return value;
+		default: return NO_MATCH;
+	}
+}
+/**
+* Coerces the props of a plain object. Copy-on-first-change: allocates the
+* output object only when some prop actually coerced, else returns the input.
+*/ function coerceProps(def, value) {
+	const keys = Object.keys(value);
+	let out;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const input = value[key];
+		let propDef = def.type.props.get(key);
+		if (!propDef) {
+			for (const { pattern, def: patternDef } of def.type.propsPatterns) if (pattern.test(key)) {
+				propDef = patternDef;
+				break;
+			}
+		}
+		let coerced = input;
+		if (propDef) {
+			const result = coerce(propDef, input);
+			if (result !== NO_MATCH) coerced = result;
+		}
+		if (out) out[key] = coerced;
+else if (coerced !== input) {
+			out = {};
+			for (let j = 0; j < i; j++) out[keys[j]] = value[keys[j]];
+			out[key] = coerced;
+		}
+	}
+	return out ?? value;
+}
+/**
+* Coerces array/tuple items against `of` (arrays) or `items[i]` (tuples).
+* Copy-on-first-change, same as {@link coerceProps}.
+*/ function coerceItems(value, of, items) {
+	let out;
+	for (let i = 0; i < value.length; i++) {
+		const input = value[i];
+		const result = coerce(of ?? items[i], input);
+		const coerced = result === NO_MATCH ? input : result;
+		if (out) out.push(coerced);
+else if (coerced !== input) {
+			out = value.slice(0, i);
+			out.push(coerced);
+		}
+	}
+	return out ?? value;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+
+//#endregion
 //#region packages/typescript/src/runtime/default-value.ts
 /**
 * Attempts to resolve a value from the mode for the given annotated type.
@@ -480,4 +607,4 @@ function deserializeTypeDef(t, resolved) {
 }
 
 //#endregion
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, detectDiscriminator, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, coerceForType, coerceScalar, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, detectDiscriminator, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.83",
+  "version": "0.1.84",
   "description": "Atscript: typescript-gen support.",
   "keywords": [
     "annotations",
@@ -63,8 +63,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@moostjs/event-cli": "^0.6.31",
-    "moost": "^0.6.31"
+    "@moostjs/event-cli": "^0.6.32",
+    "moost": "^0.6.32"
   },
   "devDependencies": {
     "@atscript/db": "^0.1.97",