@cosmicdrift/kumiko-framework 0.368.0 → 0.370.0

package/dist/env/dry-run.js

@@ -9,6 +9,24 @@
 // by parseEnv drives the output here — single source of truth.
 import { zodShape } from "./_zod-introspect.js";
 import { classifyField, getDefaultValue, getFieldDescription, pulumiConfigKey, readKumikoMeta, } from "./index.js";
+export const DRY_RUN_ENV_VAR = "KUMIKO_DRY_RUN_ENV";
+/** Reads `KUMIKO_DRY_RUN_ENV`. `1` and `true` mean `human`; an unknown value
+ *  returns undefined, so the caller decides whether to warn or boot. */
+export function parseDryRunEnvMode(raw) {
+    if (!raw)
+        return undefined;
+    const value = raw.toLowerCase();
+    if (value === "1" || value === "true" || value === "human")
+        return "human";
+    if (value === "json" || value === "pulumi" || value === "k8s" || value === "boot")
+        return value;
+    return undefined;
+}
+/** True while any dry-run mode is requested, for code that runs at module
+ *  load (key providers, secret derivation) and must not throw on missing env. */
+export function isDryRunEnvActive(env) {
+    return parseDryRunEnvMode(env[DRY_RUN_ENV_VAR]) !== undefined;
+}
 function collectFields(schema, sources) {
     const out = [];
     for (const [name, field] of Object.entries(zodShape(schema))) {
@@ -163,3 +181,35 @@ function renderK8s(fields, options) {
     }
     return `${lines.join("\n")}\n`;
 }
+function inspectionStatus(row) {
+    return row.status === "invalid" ? `invalid: ${row.message ?? "invalid value"}` : row.status;
+}
+/** Table for `KUMIKO_DRY_RUN_ENV=boot`: one row per variable with its source,
+ *  whether it is required, and whether it is set. Values are never printed. */
+export function renderEnvInspection(rows) {
+    const header = { name: "VARIABLE", source: "SOURCE", klass: "KIND" };
+    const nameWidth = Math.max(header.name.length, ...rows.map((r) => r.name.length));
+    const sourceWidth = Math.max(header.source.length, ...rows.map((r) => r.source.length));
+    const klassWidth = Math.max(header.klass.length, ...rows.map((r) => r.klass.length));
+    const line = (name, source, klass, status) => `  ${name.padEnd(nameWidth)}  ${source.padEnd(sourceWidth)}  ${klass.padEnd(klassWidth)}  ${status}`;
+    const order = { required: 0, optional: 1, withDefault: 2 };
+    const sorted = [...rows].sort((a, b) => order[a.klass] - order[b.klass] ||
+        a.source.localeCompare(b.source) ||
+        a.name.localeCompare(b.name));
+    const missing = rows.filter((r) => r.status === "missing").length;
+    const invalid = rows.filter((r) => r.status === "invalid").length;
+    const lines = [
+        "Env check (values are not printed):",
+        line(header.name, header.source, header.klass, "STATUS"),
+        ...sorted.map((r) => line(r.name, r.source, r.klass, inspectionStatus(r))),
+        "",
+    ];
+    if (invalid > 0)
+        lines.push(`${invalid} variable(s) invalid.`);
+    if (missing > 0) {
+        lines.push(`${missing} required variable(s) missing. Feature wiring was NOT validated; set them and rerun to check it.`);
+    }
+    if (invalid === 0 && missing === 0)
+        lines.push("All variables present.");
+    return `${lines.join("\n")}\n`;
+}

package/dist/env/index.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import type { FeatureDefinition } from "../engine/types/feature.js";
+import type { FeatureDefinition } from "../engine/types/feature.ts";
 export type KumikoEnvMeta = {
     readonly pulumi?: {
         /** Override the auto-derived camelCase Pulumi-config-key name. Apps
@@ -28,31 +28,54 @@ export type EnvFieldClass = "required" | "optional" | "withDefault";
 export declare function classifyField(field: z.ZodType): EnvFieldClass;
 export declare function getDefaultValue(field: z.ZodType): unknown;
 export declare function getFieldDescription(field: z.ZodType): string | undefined;
-export type ComposeEnvSchemaOptions = {
-    /** All features whose envSchemas should be merged. */
-    readonly features: readonly FeatureDefinition[];
+/** A feature whose registered env schema is visible in its type, so
+ *  `composeEnvSchema` can type the merged schema from the feature list. */
+export type FeatureWithEnvSchema<TFeature extends FeatureDefinition, TShape extends z.ZodRawShape> = TFeature & {
+    readonly envSchema: z.ZodObject<TShape>;
+};
+/** Returns `feature` typed with the env schema it registered via
+ *  `r.envSchema(schema)`. Throws when the feature registered another
+ *  instance, so the type never claims fields the runtime schema lacks. */
+export declare function featureWithEnvSchema<TFeature extends FeatureDefinition, TShape extends z.ZodRawShape>(feature: TFeature, schema: z.ZodObject<TShape>): FeatureWithEnvSchema<TFeature, TShape>;
+type EmptyShape = Record<never, never>;
+type DeclaredEnvShape<TFeature> = TFeature extends {
+    readonly envSchema: z.ZodObject<infer TShape extends z.ZodRawShape>;
+} ? string extends keyof TShape ? EmptyShape : TShape : EmptyShape;
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type OptionalShape<TShape extends z.ZodRawShape> = {
+    [Key in keyof TShape]: z.ZodOptional<TShape[Key]>;
+};
+type FeaturesEnvShape<TFeatures extends readonly FeatureDefinition[]> = UnionToIntersection<DeclaredEnvShape<TFeatures[number]>>;
+type FlattenShape<TShape> = {
+    [Key in keyof TShape]: TShape[Key];
+} & {};
+type KnownShape<TShape extends z.ZodRawShape> = string extends keyof TShape ? EmptyShape : TShape;
+/** The merged shape `composeEnvSchema` returns. With `optionalFeatures`
+ *  every feature field is typed optional: the type cannot tell which feature
+ *  a name refers to, and over-reporting `undefined` is the safe side. */
+export type ComposedEnvShape<TFeatures extends readonly FeatureDefinition[], TCore extends z.ZodRawShape, TExtend extends z.ZodRawShape, TOptionalFeatures extends readonly string[] | undefined> = Extract<FlattenShape<KnownShape<TCore> & (TOptionalFeatures extends readonly string[] ? OptionalShape<FeaturesEnvShape<TFeatures> & z.ZodRawShape> : FeaturesEnvShape<TFeatures>) & KnownShape<TExtend>>, z.ZodRawShape>;
+export type ComposeEnvSchemaOptions<TFeatures extends readonly FeatureDefinition[] = readonly FeatureDefinition[], TCore extends z.ZodRawShape = z.ZodRawShape, TExtend extends z.ZodRawShape = z.ZodRawShape, TOptionalFeatures extends readonly string[] | undefined = readonly string[] | undefined> = {
+    /** All features whose envSchemas should be merged. Bundled features type
+     *  their fragment, so passing the list inline types the merged schema. */
+    readonly features: TFeatures;
     /** App-specific env-vars (e.g. `STUDIO_ADMIN_EMAIL`). Keys here are
      *  tagged as source "app" in the resulting sources map. */
-    readonly extend?: z.ZodObject<z.ZodRawShape>;
+    readonly extend?: z.ZodObject<TExtend>;
     /** Feature-names whose env-vars should be auto-`.optional()`-wrapped.
      *  Lets an app opt out of e.g. `channel-email-smtp`'s vars without
      *  manually `.partial()`-ing each shape at the call-site. */
-    readonly optionalFeatures?: readonly string[];
+    readonly optionalFeatures?: TOptionalFeatures;
     /** Framework-core env-vars (PORT, DATABASE_URL, REDIS_URL, …) from
      *  `@cosmicdrift/kumiko-dev-server`. Keys here are tagged as source
      *  "framework-core" in error output. Conflict-detection runs across
      *  core/features/extend as one merged pool — same key declared in two
      *  layers throws KumikoBootError at compose-time. */
-    readonly core?: z.ZodObject<z.ZodRawShape>;
+    readonly core?: z.ZodObject<TCore>;
 };
-export type ComposedEnvSchema = {
-    /** The merged Zod schema. Type-erased to `ZodObject<ZodRawShape>` — TS
-     *  can't variadic-merge N generic feature schemas without tuple gymnastics
-     *  that hurt readability. For type-safe `z.infer` in app code, build a
-     *  parallel typed schema manually (see Plan-Doc
-     *  `kumiko-studio/docs/plans/sprint-9-env-schemas.md` → API-Design)
-     *  and only pass `composed.schema` to `runProdApp` for validation. */
-    readonly schema: z.ZodObject<z.ZodRawShape>;
+export type ComposedEnvSchema<TShape extends z.ZodRawShape = z.ZodRawShape> = {
+    /** The merged Zod schema, typed from core, the typed feature fragments and
+     *  extend; `parseEnv(composed.schema, env)` returns the typed env. */
+    readonly schema: z.ZodObject<TShape>;
     /** env-var-name → declaring source-name: feature-name from `r.envSchema()`,
      *  "app" from `extend`, or "framework-core" from `core`. */
     readonly sources: Readonly<Record<string, string>>;
@@ -60,7 +83,7 @@ export type ComposedEnvSchema = {
 /** Makes the named env keys optional while keeping their `kms` meta. Keys
  *  missing from the schema shape are ignored. */
 export declare function withOptionalEnvKeys(schema: z.ZodObject<z.ZodRawShape>, keys: readonly string[]): z.ZodObject<z.ZodRawShape>;
-export declare function composeEnvSchema(options: ComposeEnvSchemaOptions): ComposedEnvSchema;
+export declare function composeEnvSchema<const TFeatures extends readonly FeatureDefinition[], TCore extends z.ZodRawShape = EmptyShape, TExtend extends z.ZodRawShape = EmptyShape, const TOptionalFeatures extends readonly string[] | undefined = undefined>(options: ComposeEnvSchemaOptions<TFeatures, TCore, TExtend, TOptionalFeatures>): ComposedEnvSchema<ComposedEnvShape<TFeatures, TCore, TExtend, TOptionalFeatures>>;
 export type EnvErrorKind = "missing" | "invalid";
 export type EnvError = {
     readonly name: string;
@@ -100,6 +123,21 @@ export declare function parseEnv<S extends z.ZodObject<z.ZodRawShape>>(schema: S
  *  scheitern. Ersetzt das `({} as Shape)`-Muster, bei dem JEDER Zugriff
  *  silent undefined war und das Compile-Level nichts davon wusste. */
 export declare function parseEnvDryRun<S extends z.ZodObject<z.ZodRawShape>>(schema: S, env: Record<string, string | undefined>): Partial<z.infer<S>>;
+export type EnvFieldStatus = "set" | "unset" | "missing" | "invalid";
+export type EnvFieldInspection = {
+    readonly name: string;
+    readonly klass: EnvFieldClass;
+    readonly source: string;
+    readonly status: EnvFieldStatus;
+    /** Zod's issue text for an invalid value; never the value itself. */
+    readonly message?: string;
+};
+/** Checks every field of `schema` on its own against `env`, for the boot dry
+ *  run: a missing required value is reported, not thrown, so the inventory
+ *  renders on an empty env. Object-level refinements do not run here; once
+ *  nothing is missing or invalid, parseEnv validates the whole object. */
+export declare function inspectEnv(schema: z.ZodObject<z.ZodRawShape>, env: Readonly<Record<string, string | undefined>>, options?: Pick<ParseEnvOptions, "sources">): readonly EnvFieldInspection[];
 export declare function camelCase(snakeShout: string): string;
 export declare function pulumiConfigKey(envName: string, field: z.ZodType | undefined, prefix: string | undefined): string;
 export declare function buildPulumiSuggestion(envName: string, field: z.ZodType, prefix: string | undefined): string | undefined;
+export {};

package/dist/env/index.js

@@ -115,6 +115,18 @@ export function getDefaultValue(field) {
 export function getFieldDescription(field) {
     return zodDescription(field);
 }
+function registersEnvSchema(feature, schema) {
+    return feature.envSchema === schema;
+}
+/** Returns `feature` typed with the env schema it registered via
+ *  `r.envSchema(schema)`. Throws when the feature registered another
+ *  instance, so the type never claims fields the runtime schema lacks. */
+export function featureWithEnvSchema(feature, schema) {
+    if (!registersEnvSchema(feature, schema)) {
+        throw new Error(`[Feature ${feature.name}] featureWithEnvSchema: the feature did not register this schema instance via r.envSchema().`);
+    }
+    return feature;
+}
 // `.optional()` returns a new Zod instance that drops `.meta()`, which would
 // hide the slot from `kmsSlotsOf` on the composed schema.
 function optionalKeepingKmsMeta(field) {
@@ -214,13 +226,17 @@ export function composeEnvSchema(options) {
     }
     if (options.extend) {
         for (const [key, field] of Object.entries(zodShape(options.extend))) {
+            // An app spreading a feature's own fragment into extend re-declares the
+            // same instance; that is the feature's variable, not a second owner.
+            if (featureFields.get(key) === field)
+                continue;
             if (merged[key] !== undefined) {
                 throw new KumikoBootError([
                     {
                         name: key,
                         kind: "invalid",
-                        message: `env-var conflict: "${key}" declared by both "${sources[key]}" ` +
-                            `and the app's extend block — rename one.`,
+                        message: `env-var conflict: "${key}" is declared by "${sources[key]}" and again in the app's extend block — ` +
+                            `drop it from extend, the declaring source already owns it.`,
                     },
                 ]);
             }
@@ -230,10 +246,9 @@ export function composeEnvSchema(options) {
         }
     }
     declareKmsCiphertextTwins(merged, sources, kmsFields);
-    return {
-        schema: z.object(merged),
-        sources,
-    };
+    // @cast-boundary schema-walk — the loops above merge exactly the core, feature and extend shapes the type names; a key clash throws instead of overwriting.
+    const schema = z.object(merged);
+    return { schema, sources };
 }
 function formatBootError(errors) {
     const lines = [
@@ -346,6 +361,45 @@ export function parseEnvDryRun(schema, env) {
     // per-Feld-safeParse; jeder enthaltene Wert hat seinen Feld-Parse bestanden.
     return out;
 }
+/** Checks every field of `schema` on its own against `env`, for the boot dry
+ *  run: a missing required value is reported, not thrown, so the inventory
+ *  renders on an empty env. Object-level refinements do not run here; once
+ *  nothing is missing or invalid, parseEnv validates the whole object. */
+export function inspectEnv(schema, env, options = {}) {
+    const cleaned = {};
+    for (const [k, v] of Object.entries(env)) {
+        if (v !== undefined)
+            cleaned[k] = v;
+    }
+    const relaxed = relaxCiphertextOnlySlots(schema, cleaned);
+    return Object.entries(zodShape(relaxed)).map(([name, field]) => {
+        const klass = classifyField(field);
+        const source = options.sources?.[name] ?? "unknown";
+        const raw = cleaned[name];
+        if (raw === undefined) {
+            return { name, klass, source, status: klass === "required" ? "missing" : "unset" };
+        }
+        const issue = firstFieldIssue(field, raw);
+        return issue === undefined
+            ? { name, klass, source, status: "set" }
+            : { name, klass, source, status: "invalid", message: issue };
+    });
+}
+function firstFieldIssue(field, raw) {
+    try {
+        const result = field.safeParse(raw);
+        if (result.success)
+            return undefined;
+        const message = result.error.issues[0]?.message ?? "invalid value";
+        // A custom refine message may interpolate the input; the table must not
+        // carry it, so such a message is replaced as a whole.
+        return raw.length > 0 && message.includes(raw) ? "invalid value" : message;
+    }
+    catch {
+        // The thrown message may quote the value, so it is not passed on.
+        return "a field refinement threw while checking the value";
+    }
+}
 export function camelCase(snakeShout) {
     const parts = snakeShout.toLowerCase().split("_").filter(Boolean);
     if (parts.length === 0)

package/dist/errors/classes.d.ts

@@ -1,6 +1,6 @@
-import type { FieldIssue } from "./field-issue.js";
-import { type ErrorOpts, KumikoError } from "./kumiko-error.js";
-export type { FieldIssue } from "./field-issue.js";
+import type { FieldIssue } from "./field-issue.ts";
+import { type ErrorOpts, KumikoError } from "./kumiko-error.ts";
+export type { FieldIssue } from "./field-issue.ts";
 export type ValidationDetails = {
     readonly fields: readonly FieldIssue[];
 };

package/dist/errors/docs-url.d.ts

@@ -1,4 +1,4 @@
-import type { KumikoError } from "./kumiko-error.js";
+import type { KumikoError } from "./kumiko-error.ts";
 /** Links an app's own error reasons to its own docs; without it only framework reasons carry a docsUrl. */
 export type ErrorDocsConfig = {
     readonly baseUrl: string;

package/dist/errors/index.d.ts

@@ -1,18 +1,18 @@
-export type { FeatureDisabledDetails, FieldIssue, NotFoundDetails, PreconditionFailedDetails, RateLimitDetails, UnconfiguredDetails, UniqueViolationDetails, UnprocessableOpts, ValidationDetails, VersionConflictDetails, } from "./classes.js";
-export { AccessDeniedError, ConflictError, FeatureDisabledError, IdempotentReplayError, InternalError, MemberReadTimeoutError, NotFoundError, PreconditionFailedError, RateLimitError, RateLimitUnavailableError, RecordLockedError, UnauthenticatedError, UnconfiguredError, UniqueViolationError, UnprocessableError, ValidationError, VersionConflictError, } from "./classes.js";
-export type { ErrorDocsConfig } from "./docs-url.js";
-export { resolveErrorDocsUrl } from "./docs-url.js";
-export type { ErrorCtorInput, ErrorOpts } from "./kumiko-error.js";
-export { isKumikoError, KumikoError } from "./kumiko-error.js";
-export { memberResolutionReadOnlyDenied } from "./member-resolution.js";
-export type { AgentReason, FrameworkReason } from "./reasons.js";
-export { AgentReasons, FrameworkReasons } from "./reasons.js";
-export type { ErrorLogEntry, ErrorResponseBody } from "./serialize.js";
-export { buildErrorLog, serializeError } from "./serialize.js";
-export { isSubjectErasedConflict, subjectErasedConflict } from "./subject-erased.js";
-export { toKumikoError } from "./to-kumiko-error.js";
-export type { InvalidTransitionDetails } from "./transition-details.js";
-export { buildInvalidTransitionDetails } from "./transition-details.js";
-export type { WriteErrorInfo, WriteFailure } from "./write-error-info.js";
-export { failNotFound, failTransition, failUnprocessable, reraiseAsKumikoError, toWriteErrorInfo, writeFailure, } from "./write-error-info.js";
-export { validationErrorFromZod } from "./zod-bridge.js";
+export type { FeatureDisabledDetails, FieldIssue, NotFoundDetails, PreconditionFailedDetails, RateLimitDetails, UnconfiguredDetails, UniqueViolationDetails, UnprocessableOpts, ValidationDetails, VersionConflictDetails, } from "./classes.ts";
+export { AccessDeniedError, ConflictError, FeatureDisabledError, IdempotentReplayError, InternalError, MemberReadTimeoutError, NotFoundError, PreconditionFailedError, RateLimitError, RateLimitUnavailableError, RecordLockedError, UnauthenticatedError, UnconfiguredError, UniqueViolationError, UnprocessableError, ValidationError, VersionConflictError, } from "./classes.ts";
+export type { ErrorDocsConfig } from "./docs-url.ts";
+export { resolveErrorDocsUrl } from "./docs-url.ts";
+export type { ErrorCtorInput, ErrorOpts } from "./kumiko-error.ts";
+export { isKumikoError, KumikoError } from "./kumiko-error.ts";
+export { memberResolutionReadOnlyDenied } from "./member-resolution.ts";
+export type { AgentReason, FrameworkReason } from "./reasons.ts";
+export { AgentReasons, FrameworkReasons } from "./reasons.ts";
+export type { ErrorLogEntry, ErrorResponseBody } from "./serialize.ts";
+export { buildErrorLog, serializeError } from "./serialize.ts";
+export { isSubjectErasedConflict, subjectErasedConflict } from "./subject-erased.ts";
+export { toKumikoError } from "./to-kumiko-error.ts";
+export type { InvalidTransitionDetails } from "./transition-details.ts";
+export { buildInvalidTransitionDetails } from "./transition-details.ts";
+export type { WriteErrorInfo, WriteFailure } from "./write-error-info.ts";
+export { failNotFound, failTransition, failUnprocessable, reraiseAsKumikoError, toWriteErrorInfo, writeFailure, } from "./write-error-info.ts";
+export { validationErrorFromZod } from "./zod-bridge.ts";

package/dist/errors/member-resolution.d.ts

@@ -1,2 +1,2 @@
-import { AccessDeniedError } from "./classes.js";
+import { AccessDeniedError } from "./classes.ts";
 export declare function memberResolutionReadOnlyDenied(cause?: unknown): AccessDeniedError;

package/dist/errors/serialize.d.ts

@@ -1,5 +1,5 @@
-import { type ErrorDocsConfig } from "./docs-url.js";
-import type { KumikoError } from "./kumiko-error.js";
+import { type ErrorDocsConfig } from "./docs-url.ts";
+import type { KumikoError } from "./kumiko-error.ts";
 export type ErrorResponseBody = {
     readonly error: {
         readonly code: string;

package/dist/errors/subject-erased.d.ts

@@ -1,3 +1,3 @@
-import { ConflictError } from "./classes.js";
+import { ConflictError } from "./classes.ts";
 export declare function subjectErasedConflict(cause?: unknown): ConflictError;
 export declare function isSubjectErasedConflict(e: unknown): e is ConflictError;

package/dist/errors/to-kumiko-error.d.ts

@@ -1,2 +1,2 @@
-import { type KumikoError } from "./kumiko-error.js";
+import { type KumikoError } from "./kumiko-error.ts";
 export declare function toKumikoError(e: unknown): KumikoError;

package/dist/errors/write-error-info.d.ts

@@ -1,5 +1,5 @@
 import type { WriteErrorInfo, WriteFailure } from "@cosmicdrift/kumiko-types/write-error-info-types";
-import { KumikoError } from "./kumiko-error.js";
+import { KumikoError } from "./kumiko-error.ts";
 export type { WriteErrorInfo, WriteFailure };
 export declare function writeFailure(err: KumikoError): WriteFailure;
 export declare function failNotFound(entity: string, id?: number | string): WriteFailure;

package/dist/errors/zod-bridge.d.ts

@@ -1,3 +1,3 @@
 import type { ZodError } from "zod";
-import { ValidationError } from "./classes.js";
+import { ValidationError } from "./classes.ts";
 export declare function validationErrorFromZod(error: ZodError): ValidationError;

package/dist/es-ops/context.d.ts

@@ -1,6 +1,6 @@
-import type { DbRunner } from "../db/index.js";
-import type { Dispatcher } from "../pipeline/dispatcher.js";
-import type { SeedMigrationContext } from "./types.js";
+import type { DbRunner } from "../db/index.ts";
+import type { Dispatcher } from "../pipeline/dispatcher.ts";
+import type { SeedMigrationContext } from "./types.ts";
 export type CreateSeedMigrationContextArgs = {
     readonly dispatcher: Dispatcher;
     readonly dbRunner: DbRunner;
@@ -16,4 +16,4 @@ export type CreateSeedMigrationContextArgs = {
  *  bleiben committed. Seeds MÜSSEN deshalb idempotent sein (verifiziert in
  *  runner.integration.test.ts „dispatcher-writes vor throw bleiben committed"). */
 export declare function createSeedMigrationContext(args: CreateSeedMigrationContextArgs): SeedMigrationContext;
-export type { SeedMigrationContext } from "./types.js";
+export type { SeedMigrationContext } from "./types.ts";

package/dist/es-ops/index.d.ts

@@ -1,4 +1,4 @@
-export { type CreateSeedMigrationContextArgs, createSeedMigrationContext, } from "./context.js";
-export { createEsOperationsTable, type EsOperationAppliedBy, type EsOperationType, esOperationsTable, } from "./operations-schema.js";
-export { type RunPendingSeedMigrationsArgs, type RunPendingSeedMigrationsResult, runPendingSeedMigrations, } from "./runner.js";
-export type { SeedMembershipRow, SeedMigration, SeedMigrationContext, SeedTemplateResourceFilter, SeedTemplateResourceRow, SeedTenantRow, SeedUserRow, } from "./types.js";
+export { type CreateSeedMigrationContextArgs, createSeedMigrationContext, } from "./context.ts";
+export { createEsOperationsTable, type EsOperationAppliedBy, type EsOperationType, esOperationsTable, } from "./operations-schema.ts";
+export { type RunPendingSeedMigrationsArgs, type RunPendingSeedMigrationsResult, runPendingSeedMigrations, } from "./runner.ts";
+export type { SeedMembershipRow, SeedMigration, SeedMigrationContext, SeedTemplateResourceFilter, SeedTemplateResourceRow, SeedTenantRow, SeedUserRow, } from "./types.ts";

package/dist/es-ops/operations-schema.d.ts

@@ -1,4 +1,4 @@
-import { type DbConnection } from "../db/index.js";
+import { type DbConnection } from "../db/index.ts";
 export type EsOperationType = "seed-migration";
 export type EsOperationAppliedBy = "boot" | "cli" | "ci-pipeline";
 export declare const esOperationsTable: import("@cosmicdrift/kumiko-types/schema-table-types").SchemaTable;

package/dist/es-ops/runner.d.ts

@@ -1,6 +1,6 @@
-import type { DbConnection, DbRunner } from "../db/index.js";
-import type { Registry } from "../engine/index.js";
-import type { EsOperationAppliedBy, SeedMigrationContext } from "./types.js";
+import type { DbConnection, DbRunner } from "../db/index.ts";
+import type { Registry } from "../engine/index.ts";
+import type { EsOperationAppliedBy, SeedMigrationContext } from "./types.ts";
 export type RunPendingSeedMigrationsArgs = {
     readonly db: DbConnection;
     /** Absoluter Pfad zum seeds-Directory (typically <appRoot>/seeds). */

package/dist/es-ops/runner.js

@@ -19,6 +19,14 @@
 // `KUMIKO_SKIP_ES_OPS_<id>=1` env-flag um eine kaputte Migration zu
 // überspringen ohne ihr Code touchen zu müssen. NICHT als
 // Standard-Workflow — wirklich Notfall.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { acquireEsOpsAdvisoryLock, esOperationExists } from "../db/queries/es-ops.js";
@@ -144,7 +152,7 @@ async function loadAppliedIds(db) {
 async function loadSeedModule(filePath) {
     // Bun + Node both honor dynamic import on absolute paths. The seed-files
     // must export their SeedMigration as default.
-    const mod = await import(filePath);
+    const mod = await import(__rewriteRelativeImportExtension(filePath));
     const migration = mod.default;
     if (!isSeedMigration(migration)) {
         throw new Error(`[es-ops] seed file ${filePath} must export a SeedMigration as default ` +

package/dist/es-ops/types.d.ts

@@ -1,5 +1,5 @@
-import type { DbRunner } from "../db/index.js";
-import type { TenantId, WriteResult } from "../engine/index.js";
+import type { DbRunner } from "../db/index.ts";
+import type { TenantId, WriteResult } from "../engine/index.ts";
 export type EsOperationAppliedBy = "boot" | "cli" | "ci-pipeline";
 /** Default-Export einer seed-Migration-File. */
 export type SeedMigration = {

package/dist/event-store/admin-api.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="temporal-polyfill/global" preserve="true" />
-import type { DbRunner } from "../db/index.js";
-import type { TenantId } from "../engine/types/index.js";
-import type { EventMetadata } from "./event-store.js";
+import type { DbRunner } from "../db/index.ts";
+import type { TenantId } from "../engine/types/index.ts";
+import type { EventMetadata } from "./event-store.ts";
 export type RawEventToAppend = {
     readonly aggregateId: string;
     readonly aggregateType: string;

package/dist/event-store/archive.d.ts

@@ -1,5 +1,5 @@
-import type { DbConnection, DbRunner } from "../db/connection.js";
-import type { TenantId } from "../engine/types/index.js";
+import type { DbConnection, DbRunner } from "../db/connection.ts";
+import type { TenantId } from "../engine/types/index.ts";
 export declare const archivedStreamsTable: import("@cosmicdrift/kumiko-types/schema-table-types").SchemaTable;
 export declare function createArchivedStreamsTable(db: DbConnection): Promise<void>;
 export type ArchiveStreamArgs = {

package/dist/event-store/event-store.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="temporal-polyfill/global" preserve="true" />
 import { type EventMetadata, type StoredEvent } from "@cosmicdrift/kumiko-types/event-store-types";
 import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
-import type { DbRunner } from "../db/index.js";
-import type { TenantId } from "../engine/types/index.js";
+import type { DbRunner } from "../db/index.ts";
+import type { TenantId } from "../engine/types/index.ts";
 export type { EventMetadata, StoredEvent } from "@cosmicdrift/kumiko-types/event-store-types";
 export type EventToAppend = {
     readonly aggregateId: string;

package/dist/event-store/events-schema.d.ts

@@ -1,3 +1,3 @@
-import { type DbConnection } from "../db/index.js";
+import { type DbConnection } from "../db/index.ts";
 export declare const eventsTable: import("@cosmicdrift/kumiko-types/schema-table-types").SchemaTable;
 export declare function createEventsTable(db: DbConnection): Promise<void>;

package/dist/event-store/index.d.ts

@@ -1,15 +1,15 @@
-export { APP_INSTANCE_STREAM_TYPE, APP_STARTED_EVENT_TYPE } from "../crypto/system-event-pii.js";
-export { backfillEventPiiEncryption, backfillEventPiiEncryptionBatch, type PiiBackfillBatchOptions, type PiiBackfillBatchResult, type PiiBackfillFailure, type PiiBackfillOptions, type PiiBackfillResult, type PiiBackfillScanCache, } from "../db/queries/backfill-pii.js";
-export { type ArchiveStreamArgs, archivedStreamsTable, archiveStream, createArchivedStreamsTable, isStreamArchived, restoreStream, } from "./archive.js";
-export { ArchivedStreamError, IdempotentAppendConflictError, SeedTimeOrderError, VersionConflictError, } from "./errors.js";
-export { append, EVENTS_PUBSUB_CHANNEL, type EventMetadata, type EventToAppend, getEventsHighWaterMark, getStreamVersion, getStreamVersions, getUnscopedAggregateStreamMaxVersion, getUnscopedStreamMaxVersionForSeed, LOAD_ALL_EVENTS_ROW_LIMIT, loadAggregate, loadAggregateAsOf, loadAllEventsByType, loadEventsAfterVersion, type StoredEvent, streamAllEventsByType, } from "./event-store.js";
-export { createEventsTable, eventsTable } from "./events-schema.js";
-export { appendProvenanceEvent, type ProvenanceEventInput } from "./provenance-append.js";
-export { createRebuildDeadLetterTable, listRebuildDeadLetters, type RebuildDeadLetterRow, rebuildDeadLetterTable, recordRebuildDeadLetters, type SkippedApply, } from "./rebuild-dead-letter.js";
-export { toStoredEvent } from "./row-to-stored-event.js";
-export { assertSeedModeNotInProduction, isSeedModeEnabled, runSeedWritesAt, SEED_MODE_ENV, SeedModeDisabledError, } from "./seed-clock.js";
-export { createSnapshotsTable, type LoadAggregateWithSnapshotOptions, type LoadAggregateWithSnapshotResult, loadAggregateWithSnapshot, loadLatestSnapshot, type SaveSnapshotArgs, type Snapshot, type SnapshotReducer, saveSnapshot, snapshotsTable, } from "./snapshot.js";
-export { type AppendEventInTenantDbOptions, appendEventInTenantDb, getStreamVersionInTenantDb, } from "./tenant-db-append.js";
-export { AGGREGATE_TRANSFER_STREAM_TYPE, AGGREGATE_TRANSFERRED_EVENT_TYPE, type TransferAggregateStreamsArgs, transferAggregateStreams, } from "./transfer.js";
-export { type EventUpcasters, makeUpcastCtx, type UpcasterErrorPolicy, type UpcastOptions, upcastStoredEvent, upcastStoredEvents, } from "./upcaster.js";
-export { createUpcasterDeadLetterTable, type DeadLetterRow, listDeadLetters, recordUpcasterDeadLetter, upcasterDeadLetterTable, } from "./upcaster-dead-letter.js";
+export { APP_INSTANCE_STREAM_TYPE, APP_STARTED_EVENT_TYPE } from "../crypto/system-event-pii.ts";
+export { backfillEventPiiEncryption, backfillEventPiiEncryptionBatch, type PiiBackfillBatchOptions, type PiiBackfillBatchResult, type PiiBackfillFailure, type PiiBackfillOptions, type PiiBackfillResult, type PiiBackfillScanCache, } from "../db/queries/backfill-pii.ts";
+export { type ArchiveStreamArgs, archivedStreamsTable, archiveStream, createArchivedStreamsTable, isStreamArchived, restoreStream, } from "./archive.ts";
+export { ArchivedStreamError, IdempotentAppendConflictError, SeedTimeOrderError, VersionConflictError, } from "./errors.ts";
+export { append, EVENTS_PUBSUB_CHANNEL, type EventMetadata, type EventToAppend, getEventsHighWaterMark, getStreamVersion, getStreamVersions, getUnscopedAggregateStreamMaxVersion, getUnscopedStreamMaxVersionForSeed, LOAD_ALL_EVENTS_ROW_LIMIT, loadAggregate, loadAggregateAsOf, loadAllEventsByType, loadEventsAfterVersion, type StoredEvent, streamAllEventsByType, } from "./event-store.ts";
+export { createEventsTable, eventsTable } from "./events-schema.ts";
+export { appendProvenanceEvent, type ProvenanceEventInput } from "./provenance-append.ts";
+export { createRebuildDeadLetterTable, listRebuildDeadLetters, type RebuildDeadLetterRow, rebuildDeadLetterTable, recordRebuildDeadLetters, type SkippedApply, } from "./rebuild-dead-letter.ts";
+export { toStoredEvent } from "./row-to-stored-event.ts";
+export { assertSeedModeNotInProduction, isSeedModeEnabled, runSeedWritesAt, SEED_MODE_ENV, SeedModeDisabledError, } from "./seed-clock.ts";
+export { createSnapshotsTable, type LoadAggregateWithSnapshotOptions, type LoadAggregateWithSnapshotResult, loadAggregateWithSnapshot, loadLatestSnapshot, type SaveSnapshotArgs, type Snapshot, type SnapshotReducer, saveSnapshot, snapshotsTable, } from "./snapshot.ts";
+export { type AppendEventInTenantDbOptions, appendEventInTenantDb, getStreamVersionInTenantDb, } from "./tenant-db-append.ts";
+export { AGGREGATE_TRANSFER_STREAM_TYPE, AGGREGATE_TRANSFERRED_EVENT_TYPE, type TransferAggregateStreamsArgs, transferAggregateStreams, } from "./transfer.ts";
+export { type EventUpcasters, makeUpcastCtx, type UpcasterErrorPolicy, type UpcastOptions, upcastStoredEvent, upcastStoredEvents, } from "./upcaster.ts";
+export { createUpcasterDeadLetterTable, type DeadLetterRow, listDeadLetters, recordUpcasterDeadLetter, upcasterDeadLetterTable, } from "./upcaster-dead-letter.ts";

package/dist/event-store/provenance-append.d.ts

@@ -1,6 +1,6 @@
-import { type TenantDb } from "../db/tenant-db.js";
-import type { TenantId } from "../engine/types/index.js";
-import { type EventMetadata } from "./event-store.js";
+import { type TenantDb } from "../db/tenant-db.ts";
+import type { TenantId } from "../engine/types/index.ts";
+import { type EventMetadata } from "./event-store.ts";
 export type ProvenanceEventInput = {
     readonly aggregateId: string;
     readonly aggregateType: string;

package/dist/event-store/rebuild-dead-letter.d.ts

@@ -1,5 +1,5 @@
-import type { DbConnection, DbRunner } from "../db/connection.js";
-import type { StoredEvent } from "./event-store.js";
+import type { DbConnection, DbRunner } from "../db/connection.ts";
+import type { StoredEvent } from "./event-store.ts";
 export declare const rebuildDeadLetterTable: import("@cosmicdrift/kumiko-types/schema-table-types").SchemaTable;
 export declare function createRebuildDeadLetterTable(db: DbConnection): Promise<void>;
 export type SkippedApply = {

package/dist/event-store/row-to-stored-event.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="temporal-polyfill/global" preserve="true" />
-import type { TenantId } from "../engine/types/index.js";
-import type { EventMetadata, StoredEvent } from "./event-store.js";
+import type { TenantId } from "../engine/types/index.ts";
+import type { EventMetadata, StoredEvent } from "./event-store.ts";
 type EventRow = {
     readonly id: bigint;
     readonly aggregateId: string;

package/dist/event-store/snapshot.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="temporal-polyfill/global" preserve="true" />
 import type { LoadAggregateWithSnapshotOptions, LoadAggregateWithSnapshotResult, SnapshotReducer } from "@cosmicdrift/kumiko-types/snapshot-types";
-import type { DbConnection, DbRunner } from "../db/connection.js";
-import type { TenantId } from "../engine/types/index.js";
+import type { DbConnection, DbRunner } from "../db/connection.ts";
+import type { TenantId } from "../engine/types/index.ts";
 export declare const snapshotsTable: import("@cosmicdrift/kumiko-types/schema-table-types").SchemaTable;
 export declare function createSnapshotsTable(db: DbConnection): Promise<void>;
 export declare function effectiveSnapshotGeneration(callerVersion: number, entityEventVersion: number | undefined): number;

package/dist/event-store/tenant-db-append.d.ts

@@ -1,6 +1,6 @@
 import type { TenantDb } from "@cosmicdrift/kumiko-types/tenant-db-types";
-import type { Registry } from "../engine/types/index.js";
-import { type EventToAppend, type StoredEvent } from "./event-store.js";
+import type { Registry } from "../engine/types/index.ts";
+import { type EventToAppend, type StoredEvent } from "./event-store.ts";
 export type AppendEventInTenantDbOptions = {
     readonly registry?: Registry;
 };

package/dist/event-store/transfer.d.ts

@@ -1,6 +1,6 @@
-import { AGGREGATE_TRANSFERRED_EVENT_TYPE } from "../crypto/system-event-pii.js";
-import type { DbRunner } from "../db/index.js";
-import type { TenantId } from "../engine/types/index.js";
+import { AGGREGATE_TRANSFERRED_EVENT_TYPE } from "../crypto/system-event-pii.ts";
+import type { DbRunner } from "../db/index.ts";
+import type { TenantId } from "../engine/types/index.ts";
 export declare const AGGREGATE_TRANSFER_STREAM_TYPE = "aggregate-transfer";
 export { AGGREGATE_TRANSFERRED_EVENT_TYPE };
 export type TransferAggregateStreamsArgs = {

package/dist/event-store/upcaster-dead-letter.d.ts

@@ -1,5 +1,5 @@
-import type { DbConnection, DbRunner } from "../db/connection.js";
-import type { StoredEvent } from "./event-store.js";
+import type { DbConnection, DbRunner } from "../db/connection.ts";
+import type { StoredEvent } from "./event-store.ts";
 export declare const upcasterDeadLetterTable: import("@cosmicdrift/kumiko-types/schema-table-types").SchemaTable;
 export declare function createUpcasterDeadLetterTable(db: DbConnection): Promise<void>;
 export declare function recordUpcasterDeadLetter(db: DbRunner, args: {

package/dist/event-store/upcaster.d.ts

@@ -1,6 +1,6 @@
-import type { DbRunner } from "../db/index.js";
-import type { EventUpcastCtx, EventUpcastFn, TenantId } from "../engine/types/index.js";
-import type { StoredEvent } from "./event-store.js";
+import type { DbRunner } from "../db/index.ts";
+import type { EventUpcastCtx, EventUpcastFn, TenantId } from "../engine/types/index.ts";
+import type { StoredEvent } from "./event-store.ts";
 export type UpcasterErrorPolicy = "throw" | "quarantine";
 export type UpcastOptions = {
     readonly errorPolicy?: UpcasterErrorPolicy;