@aventara/client 1.0.0-rc.1 → 1.0.0-rc.10

package/dist/emit/scalar.codec.js

@@ -231,13 +231,18 @@ function copyJson(side: Side, value: unknown, path: Path, ancestors: Set<object>
 	if (Array.isArray(value)) {
 		const items: unknown[] = [];
 		for (let index = 0; index < value.length; index += 1) {
-			items.push(copyJson(side, value[index], [...path, index], ancestors));
+			// An undefined element (or a hole) is null, as JSON writes it (rc.2).
+			const item = value[index];
+			items.push(item === undefined ? null : copyJson(side, item, [...path, index], ancestors));
 		}
 		copy = items;
 	} else {
-		// fromEntries defines each key, so "__proto__" stays an own key.
+		// fromEntries defines each key, so "__proto__" stays an own key. A key holding
+		// undefined is left out, as JSON leaves it out (rc.2).
 		copy = Object.fromEntries(
-			Object.entries(value).map(([key, member]) => [key, copyJson(side, member, [...path, key], ancestors)]),
+			Object.entries(value)
+				.filter(([, member]) => member !== undefined)
+				.map(([key, member]) => [key, copyJson(side, member, [...path, key], ancestors)]),
 		);
 	}
 	ancestors.delete(value);
@@ -271,8 +276,10 @@ function writeWireJson(value: unknown, path: Path, ancestors: Set<object>): stri
 	if (Array.isArray(value)) {
 		const items: string[] = [];
 		for (let index = 0; index < value.length; index += 1) {
-			// An undefined element is refused, not stripped: JSON would make it null.
-			items.push(writeWireJson(value[index], [...path, index], ancestors));
+			// An undefined element (or a hole) is null, as JSON writes it (rc.2): the
+			// server reads the same value from an in-process caller.
+			const item = value[index];
+			items.push(item === undefined ? "null" : writeWireJson(item, [...path, index], ancestors));
 		}
 		text = "[" + items.join(",") + "]";
 	} else {
@@ -310,7 +317,8 @@ export function decodeScalar(scalar: AvBuiltInScalar, wire: unknown): unknown {
 /**
  * The JSON text of a request body whose scalars are already encoded. Every
  * undefined property is stripped, at every depth (an optional property is
- * omitted, never sent), and null is kept as the explicit value it is.
+ * omitted, never sent), an undefined array element is null, as JSON.stringify
+ * writes both, and null is kept as the explicit value it is.
  * Anything else that is not JSON-safe is refused rather than coerced: it means a
  * value escaped its scalar codec.
  */
@@ -347,6 +355,215 @@ export function readArgument<T>(path: Path, read: () => T): T {
 	}
 }
 
+/** Where each relation directive holds the records its target writes; its other members select. */
+export const RECORD_SITES: { readonly [directive: string]: readonly (string | undefined)[] } = {
+	$create: [undefined],
+	$connect: [],
+	$connectOrCreate: ["create"],
+	$disconnect: [],
+	$set: [],
+	$update: ["data"],
+	$delete: [],
+	$upsert: ["create", "update"],
+};
+
+/** The members of an operation's arguments that hold its write records. */
+export function writeKeysOf(family: string): readonly string[] {
+	return family === "create" || family === "update" ? ["data"] : family === "upsert" ? ["create", "update"] : [];
+}
+
+/** The code an unsent value is refused with: the server's for that place. */
+export type UnsentCode = "V1001" | "V1007" | "V1009";
+
+/** One value a request would leave out: where it is, and the server's code for it. */
+export interface UnsentValue {
+	readonly path: Path;
+	readonly code: UnsentCode;
+}
+
+/**
+ * Every undefined value an operation's arguments hold where leaving it out would
+ * reach more rows than the caller wrote, in argument order, each with the code the
+ * server answers it with:
+ *
+ * - inside a filter, a unique selector or a cursor, at any depth: a where (AND, OR,
+ *   NOT, a relation filter, an operator object, an in list), a cursor, the where and
+ *   cursor of a relation that select or include reads, and a nested write's
+ *   selectors (what $connect, $disconnect, $set and $delete name, and the where of
+ *   $update, $upsert and $connectOrCreate) (V1001);
+ * - a where, cursor, limit or offset that is itself undefined, as a call's or a
+ *   relation's argument (V1001; a unique variant's where V1007, a cursor V1009),
+ *   and the where of $update (V1001), $upsert or $connectOrCreate (V1007).
+ *
+ * JSON drops an undefined value, so such a value is never sent. An undefined field
+ * of a write record is not sent, which is what leaving it out means; a projection,
+ * an order or a directive left undefined is left out as well.
+ */
+export function unsentValues(
+	table: DecodeTable,
+	resource: string,
+	family: string,
+	variant: string,
+	args: unknown,
+): UnsentValue[] {
+	const found: UnsentValue[] = [];
+	const ancestors = new Set<object>();
+
+	const listAt = (value: unknown, path: Path): readonly unknown[] | undefined =>
+		typeof value === "object" && value !== null && readArgument(path, () => Array.isArray(value))
+			? (value as readonly unknown[])
+			: undefined;
+	const recordAt = (value: unknown, path: Path): Readonly<Record<string, unknown>> | undefined =>
+		typeof value === "object" && value !== null && readArgument(path, () => !Array.isArray(value) && isPlainRecord(value))
+			? (value as Readonly<Record<string, unknown>>)
+			: undefined;
+
+	// Visits each member of a container in order (each entry of a list, each key of a
+	// record), undefined ones only when asked; a container met again on its own
+	// ancestry is not walked again, and the encoder refuses it.
+	const each = (
+		container: readonly unknown[] | Readonly<Record<string, unknown>>,
+		path: Path,
+		withUndefined: boolean,
+		visit: (key: string | number, value: unknown, at: Path) => void,
+	): void => {
+		if (ancestors.has(container)) {
+			return;
+		}
+		ancestors.add(container);
+		const keys: readonly (string | number)[] = Array.isArray(container)
+			? Array.from({ length: readArgument(path, () => container.length) }, (_, index) => index)
+			: readArgument(path, () => Object.keys(container));
+		for (const key of keys) {
+			const at = [...path, key];
+			const value = readArgument(at, () => (container as Readonly<Record<string | number, unknown>>)[key]);
+			if (withUndefined || value !== undefined) {
+				visit(key, value, at);
+			}
+		}
+		ancestors.delete(container);
+	};
+	// One entry, or each entry of a list.
+	const entries = (value: unknown, path: Path, visit: (entry: unknown, at: Path) => void): void => {
+		const list = listAt(value, path);
+		if (list === undefined) {
+			visit(value, path);
+		} else {
+			each(list, path, true, (_index, entry, at) => visit(entry, at));
+		}
+	};
+
+	const filter = (value: unknown, path: Path): void => {
+		if (value === undefined) {
+			found.push({ path, code: "V1001" });
+			return;
+		}
+		const container = listAt(value, path) ?? recordAt(value, path);
+		if (container !== undefined) {
+			each(container, path, true, (_key, member, at) => filter(member, at));
+		}
+	};
+	// A read's own arguments (a call's, or a relation's under select or include):
+	// its where and cursor are filters, its limit and offset bound what it returns.
+	const read = (key: string | number, value: unknown, at: Path, whereCode: UnsentCode, cursorCode: UnsentCode): void => {
+		if (key === "where" || key === "cursor") {
+			if (value === undefined) {
+				found.push({ path: at, code: key === "where" ? whereCode : cursorCode });
+			} else {
+				filter(value, at);
+			}
+		} else if (key === "limit" || key === "offset") {
+			if (value === undefined) {
+				found.push({ path: at, code: "V1001" });
+			}
+		} else if ((key === "select" || key === "include") && value !== undefined) {
+			projection(value, at);
+		}
+	};
+	const projection = (value: unknown, path: Path): void => {
+		const list = listAt(value, path);
+		if (list === undefined) {
+			return;
+		}
+		each(list, path, false, (_index, entry, at) => {
+			const relations = recordAt(entry, at);
+			if (relations === undefined) {
+				return;
+			}
+			each(relations, at, false, (_relation, nested, nestedAt) => {
+				const args = recordAt(nested, nestedAt);
+				if (args !== undefined) {
+					each(args, nestedAt, true, (key, member, memberAt) => read(key, member, memberAt, "V1001", "V1009"));
+				}
+			});
+		});
+	};
+	const writeRecord = (target: string, value: unknown, path: Path): void => {
+		const record = recordAt(value, path);
+		if (record === undefined) {
+			return;
+		}
+		const fields = Object.hasOwn(table, target) ? table[target] : undefined;
+		each(record, path, false, (key, member, at) => {
+			const decoding = fields !== undefined && Object.hasOwn(fields, key) ? fields[key as string] : undefined;
+			if (typeof decoding === "object") {
+				relationWrite(decoding.relation, member, at);
+			}
+		});
+	};
+	const relationWrite = (target: string, value: unknown, path: Path): void => {
+		const directives = recordAt(value, path);
+		if (directives === undefined) {
+			return;
+		}
+		each(directives, path, false, (directive, operand, at) => {
+			const sites = Object.hasOwn(RECORD_SITES, directive) ? RECORD_SITES[directive as string] : undefined;
+			if (sites === undefined) {
+				return;
+			}
+			if (sites.length === 0) {
+				filter(operand, at);
+				return;
+			}
+			entries(operand, at, (entry, entryAt) => {
+				if (sites.includes(undefined)) {
+					writeRecord(target, entry, entryAt);
+					return;
+				}
+				const parts = recordAt(entry, entryAt);
+				if (parts !== undefined) {
+					each(parts, entryAt, true, (key, member, memberAt) => {
+						if (sites.includes(key as string)) {
+							writeRecord(target, member, memberAt);
+						} else if (member !== undefined) {
+							filter(member, memberAt);
+						} else if (key === "where") {
+							found.push({ path: memberAt, code: directive === "$update" ? "V1001" : "V1007" });
+						}
+					});
+				}
+			});
+		});
+	};
+
+	const root = recordAt(args, []);
+	if (root !== undefined) {
+		const writeKeys = writeKeysOf(family);
+		const whereCode: UnsentCode = variant === "unique" ? "V1007" : "V1001";
+		const cursorCode: UnsentCode = family === "find" && variant === "many" ? "V1009" : "V1001";
+		each(root, [], true, (key, value, at) => {
+			if (writeKeys.includes(key as string)) {
+				if (value !== undefined) {
+					entries(value, at, (entry, entryAt) => writeRecord(resource, entry, entryAt));
+				}
+			} else {
+				read(key, value, at, whereCode, cursorCode);
+			}
+		});
+	}
+	return found;
+}
+
 /** How encodeValue treats an object: a scalar's runtime class, a container, or neither. */
 function objectKind(value: object): "datetime" | "decimal" | "bytes" | "container" | "other" {
 	if (value instanceof Date) {

package/dist/emit/transaction.emitter.js

@@ -212,7 +212,7 @@ function transactionModuleSource(from) {
     return `import { encodeArguments, readArgument, serializeWireBody } from ${from("./codec")};
 import { type AvCause, type AvError, frameworkErrorOf } from ${from("./errors")};
 import { fingerprintOf } from ${from("./fingerprint")};
-import { type AvCallOptions, executePlan, type TransportConnection } from ${from("./transport")};
+import { type AvCallOptions, executePlan, refuseUnsentValues, type TransportConnection } from ${from("./transport")};
 
 /**
  * The deferred transaction builder and runner: \`avClient.tx\` defers an operation
@@ -384,8 +384,11 @@ export type PlanCheck = (
  * generated client, one handle twice (AvValidationError A2004 / V1001 at
  * ["operations", i]: the entry itself); a reference to a handle not in the list (AvValidationError A2007 /
  * V1010 at its \`$ref\`); a handle whose arguments could not be read when it was
- * built (the TypeError naming where); and, when \`check\` is given, a step whose
- * values break a field check (AvValidationError A2004, as the server answers it).
+ * built (the TypeError naming where); a step holding an undefined value JSON would
+ * leave out to widen it (AvValidationError A2004, as refuseUnsentValues states it,
+ * the step named);
+ * and, when \`check\` is given, a step whose values break a field check
+ * (AvValidationError A2004, as the server answers it).
  */
 export async function runTransaction(
 	connection: TransportConnection,
@@ -431,6 +434,7 @@ export async function runTransaction(
 				});
 			}
 		}
+		refuseUnsentValues(record.resource, record.family, record.variant, record.args, ["operations", index, "args"], index);
 	}
 
 	check?.(records);

package/dist/generate.d.ts

@@ -3,7 +3,7 @@ import { type ProcessEnvInput } from "./config/env.cascade.js";
 import { type ContractFetch } from "./contract/contract.fetcher.js";
 import { type EmittedFilePath } from "./emit/emitted-tree.interface.js";
 import type { OutputCheck, TypeScriptResolver } from "./output/output.validator.js";
-export interface ClientGenerationInput {
+interface ClientGenerationInput {
     /** The project directory: where `framework.client.ts` and the `.env` files are. */
     readonly directory: string;
     /** A snapshot of the process environment. Never mutated. */
@@ -25,7 +25,7 @@ export interface ClientGenerationInput {
     readonly step?: GenerationStep;
 }
 /** Runs one phase of a generation under its title, resolving to what it returns. */
-export type GenerationStep = <T>(title: string, body: () => Promise<T> | T) => Promise<T>;
+type GenerationStep = <T>(title: string, body: () => Promise<T> | T) => Promise<T>;
 export interface ClientGenerated {
     readonly kind: "generated";
     /** The shared directory the client was generated into. */
@@ -79,3 +79,4 @@ export type ClientGenerationOutcome = ClientGenerated | ClientUpToDate | Foreign
  *   is a defect.
  */
 export declare function generateClient(input: ClientGenerationInput): Promise<ClientGenerationOutcome>;
+export {};

package/dist/generate.js

@@ -51,7 +51,7 @@ export async function generateClient(input) {
         const emission = emitClientTree(contract, config.entrypoint, {
             importFileExtension: style.importFileExtension,
             moduleFormat: style.moduleFormat,
-        });
+        }, undefined, config.accessOrigins);
         return {
             emission,
             upToDate: notModified &&

package/dist/hydration/hydration-tag.format.d.ts

@@ -0,0 +1,11 @@
+/** The tagged form a dehydrated value takes: `{ [tagKey]: <tag>, [valueKey]: <wire form> }`. */
+export declare const HYDRATION_FORMAT: {
+    /** The key a tag is under. */
+    readonly tagKey: "$av";
+    /** The key the tagged value's wire form is under. */
+    readonly valueKey: "v";
+    /** The tag of a plain object that holds `tagKey` as data. */
+    readonly objectTag: "object";
+    /** The scalars a value is tagged as: those whose runtime values JSON does not carry. */
+    readonly scalarTags: readonly ["bigint", "bytes", "datetime", "decimal"];
+};

package/dist/hydration/hydration-tag.format.js

@@ -0,0 +1,6 @@
+export const HYDRATION_FORMAT = {
+    tagKey: "$av",
+    valueKey: "v",
+    objectTag: "object",
+    scalarTags: ["bigint", "bytes", "datetime", "decimal"],
+};

package/dist/init/client-init.planner.d.ts

@@ -2,11 +2,11 @@ import type { ClientInitAnswers } from "./client-init.questions.js";
 import type { ClientProject } from "./client-project.inspector.js";
 export declare const GENERATE_SCRIPT = "avclient:generate";
 /** One change to a project file: its new content, or `undefined` to remove it. */
-export type ClientInitWrite = {
+type ClientInitWrite = {
     readonly path: string;
     readonly content: string | undefined;
 };
-export type ClientInitPlan = {
+type ClientInitPlan = {
     readonly keeping: readonly ClientInitWrite[];
     readonly replacing: readonly ClientInitWrite[];
     readonly conflicts: readonly string[];
@@ -16,3 +16,4 @@ export declare function planClientInit(input: {
     readonly answers: ClientInitAnswers;
     readonly clientVersion: string;
 }): ClientInitPlan;
+export {};

package/dist/init/client-init.questions.d.ts

@@ -15,18 +15,7 @@ export declare class AvClientInitAnswerError extends Error {
 export declare class AvClientInitUnansweredError extends Error {
     readonly name = "AvClientInitUnansweredError";
 }
-export type ClientInitQuestion = {
-    readonly id: QuestionId;
-    readonly flag: string;
-    readonly placeholder: string;
-    readonly label: string;
-    readonly defaultFor: (detectedPackageManager: PackageManager) => string;
-    /** @throws AvClientInitAnswerError */
-    readonly parse: (raw: string) => string;
-};
-export declare const DEFAULT_ENV_VAR = "AVENTARA_API_URL";
-export declare const CLIENT_INIT_QUESTIONS: readonly ClientInitQuestion[];
-export type ClientInitSources = {
+type ClientInitSources = {
     readonly given: Readonly<Partial<Record<QuestionId, string>>>;
     /** `--no-env-var`: the entrypoint is written as a literal, and no variable is asked. */
     readonly noEnvVar: boolean;

package/dist/init/client-init.questions.js

@@ -6,8 +6,8 @@ export class AvClientInitAnswerError extends Error {
 export class AvClientInitUnansweredError extends Error {
     name = "AvClientInitUnansweredError";
 }
-export const DEFAULT_ENV_VAR = "AVENTARA_API_URL";
-export const CLIENT_INIT_QUESTIONS = [
+const DEFAULT_ENV_VAR = "AVENTARA_API_URL";
+const CLIENT_INIT_QUESTIONS = [
     {
         id: "entrypoint",
         flag: "--entrypoint",

package/dist/internal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `@aventara/client/internal` is not public API.
+ *
+ * It holds what Aventara's own packages need from the client generator and an
+ * application does not. It carries no stability promise: any export here may
+ * change or disappear in any release, including a patch release.
+ */
+export type { ClientEntrypoint, EmittedEntrypoint, SameOriginEntrypoint, } from "./config/client-config.interface.js";
+export { AvClientConfigError, sameOriginEntrypoint, } from "./config/config.resolver.js";
+export type { EnvCascadeResolution } from "./config/env.cascade.js";
+export { AvEnvFileError, resolveEnvCascade } from "./config/env.cascade.js";
+export { resolveModuleStyle } from "./config/module-style.resolver.js";
+export type { ContractAcceptance } from "./contract/contract.acceptance.js";
+export { acceptClientContract } from "./contract/contract.acceptance.js";
+export { accessVerbsOf } from "./emit/access.emitter.js";
+export type { RegenerateCommand } from "./emit/banner.emitter.js";
+export { carriesGeneratedOwnership } from "./emit/banner.emitter.js";
+export type { ClientClassExport } from "./emit/client-tree.emitter.js";
+export { clientEntryReExports, emitClientTree, } from "./emit/client-tree.emitter.js";
+export type { ClientEmission, EmittedFile, EmittedTree, } from "./emit/emitted-tree.interface.js";
+export { GENERATED_DIRECTORY } from "./emit/emitted-tree.interface.js";
+export type { ClientModuleStyle } from "./emit/module-style.interface.js";
+export { importSpecifier } from "./emit/module-style.interface.js";
+export { AvGeneratedNameError } from "./emit/name.deriver.js";
+export { HYDRATION_FORMAT } from "./hydration/hydration-tag.format.js";

package/dist/internal.js

@@ -0,0 +1,11 @@
+export { AvClientConfigError, sameOriginEntrypoint, } from "./config/config.resolver.js";
+export { AvEnvFileError, resolveEnvCascade } from "./config/env.cascade.js";
+export { resolveModuleStyle } from "./config/module-style.resolver.js";
+export { acceptClientContract } from "./contract/contract.acceptance.js";
+export { accessVerbsOf } from "./emit/access.emitter.js";
+export { carriesGeneratedOwnership } from "./emit/banner.emitter.js";
+export { clientEntryReExports, emitClientTree, } from "./emit/client-tree.emitter.js";
+export { GENERATED_DIRECTORY } from "./emit/emitted-tree.interface.js";
+export { importSpecifier } from "./emit/module-style.interface.js";
+export { AvGeneratedNameError } from "./emit/name.deriver.js";
+export { HYDRATION_FORMAT } from "./hydration/hydration-tag.format.js";

package/dist/output/output.validator.d.ts

@@ -14,7 +14,7 @@ export type TypeScriptResolver = () => Promise<TypeScriptCompiler | undefined>;
  */
 export declare function typeScriptResolverFor(specifier: string, directory: string): TypeScriptResolver;
 export declare function projectTypeScriptResolver(generateAt: string): TypeScriptResolver;
-export declare const MINIMUM_TYPESCRIPT = "5.5.0";
+export declare const MINIMUM_TYPESCRIPT = "5.7.0";
 /** How deeply the tree was judged. */
 export type OutputCheck = "types" | "syntax" | "shape";
 export interface OutputAccepted {
@@ -45,9 +45,8 @@ export declare const SYNTAX_CHECK_UNAVAILABLE_WARNING: string;
 export declare function typeScriptWithoutCompilerApiWarning(version: string, checked: "syntax" | "shape"): string;
 /**
  * The warning a run carries when the project's `typescript` is older than the
- * peer range: its compiler API lacks options the check sets (`Bundler`
- * resolution, `verbatimModuleSyntax`), so its verdict would not be the one a
- * supported compiler gives.
+ * peer range: Aventara's types are not measured under it, so its verdict
+ * would not be the one a supported compiler gives.
  */
 export declare function typeScriptBelowRangeWarning(version: string, checked: "syntax" | "shape"): string;
 /**

package/dist/output/output.validator.js

@@ -24,7 +24,7 @@ export function typeScriptResolverFor(specifier, directory) {
 export function projectTypeScriptResolver(generateAt) {
     return typeScriptResolverFor("typescript", generateAt);
 }
-export const MINIMUM_TYPESCRIPT = "5.5.0";
+export const MINIMUM_TYPESCRIPT = "5.7.0";
 function meetsMinimum(version) {
     const parts = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
     const minimum = MINIMUM_TYPESCRIPT.split(".").map(Number);
@@ -57,7 +57,7 @@ export const SYNTAX_CHECK_UNAVAILABLE_WARNING = "neither `typescript` nor Node's
 export function typeScriptWithoutCompilerApiWarning(version, checked) {
     return (`the installed \`typescript\` ${version} has no classic compiler API (\`createProgram\`), so the generated ` +
         `output was NOT type-checked${checked === "shape" ? " or parsed — only its shape was" : " — only its shape and syntax were"}. ` +
-        "Your project's own `tsc` checks it when it compiles; a `typescript` 5.5 to 6 restores the generator's own type check.");
+        "Your project's own `tsc` checks it when it compiles; a `typescript` 5.7 to 6 restores the generator's own type check.");
 }
 export function typeScriptBelowRangeWarning(version, checked) {
     return (`the installed \`typescript\` ${version} is older than ${MINIMUM_TYPESCRIPT}, the lowest @aventara/client supports, so the generated ` +

package/dist/output/output.writer.d.ts

@@ -32,7 +32,7 @@ export declare function precedeDefect(defect: unknown, earlier: readonly string[
  */
 export declare function warningsRaisedBeforeDefect(defect: unknown): readonly string[];
 export type OutputFileSystem = Pick<typeof fsPromises, "lstat" | "mkdir" | "open" | "readdir" | "rename" | "rm" | "rmdir" | "writeFile">;
-export interface ClientOutputWriteInput {
+interface ClientOutputWriteInput {
     /** What `emitClientTree` returned: the tree, and the warnings it raised. */
     readonly emission: ClientEmission;
     readonly generateAt: AbsolutePath;
@@ -40,7 +40,7 @@ export interface ClientOutputWriteInput {
     readonly resolveTypeScript?: TypeScriptResolver;
     readonly fileSystem?: OutputFileSystem;
 }
-export interface ClientOutputWritten {
+interface ClientOutputWritten {
     readonly generateAt: AbsolutePath;
     readonly checked: OutputCheck;
     readonly warnings: readonly string[];
@@ -58,3 +58,4 @@ export declare function writeClientOutput(input: ClientOutputWriteInput): Promis
  */
 export declare function findForeignOutputContent(generateAt: AbsolutePath, fileSystem?: OutputFileSystem): Promise<readonly string[]>;
 export declare function ownedOutputMatches(generateAt: AbsolutePath, tree: EmittedTree): Promise<boolean>;
+export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@aventara/client",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.10",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Development-time generator for Aventara typed remote clients.",
   "type": "module",
   "engines": {
-    "node": "^22.18.0 || >=24.2.0"
+    "node": "^22.23.4 || >=24.22.1"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,6 +16,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
     }
   },
   "files": [
@@ -24,12 +28,12 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.1",
+    "@aventara/core": "1.0.0-rc.10",
     "c12": "3.3.4",
     "get-tsconfig": "4.10.0"
   },
   "peerDependencies": {
-    "typescript": ">=5.5.0"
+    "typescript": ">=5.7.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -40,7 +44,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aventara/testing": "1.0.0-rc.1",
+    "@aventara/testing": "1.0.0-rc.10",
     "@types/node": "24.10.1",
     "typescript": "^5.9.2"
   },