joist-codegen 2.4.0-next.37 → 2.4.0-next.39

package/build/config.d.cts

@@ -15,7 +15,7 @@ declare const fieldConfig: z.ZodObject<{
   hasDefault: z.ZodOptional<z.ZodBoolean>;
   lazy: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-type FieldConfig = z.infer<typeof fieldConfig>;
+export type FieldConfig = z.infer<typeof fieldConfig>;
 declare const relationConfig: z.ZodObject<{
   derived: z.ZodOptional<z.ZodLiteral<"async">>;
   polymorphic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"notNull">, z.ZodLiteral<true>]>>;
@@ -28,7 +28,7 @@ declare const relationConfig: z.ZodObject<{
   notNull: z.ZodOptional<z.ZodBoolean>;
   hasDefault: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-type RelationConfig = z.infer<typeof relationConfig>;
+export type RelationConfig = z.infer<typeof relationConfig>;
 declare const entityConfig: z.ZodObject<{
   tag: z.ZodString;
   tableName: z.ZodOptional<z.ZodString>;
@@ -62,13 +62,13 @@ declare const entityConfig: z.ZodObject<{
   orderBy: z.ZodOptional<z.ZodString>;
   uniqueBy: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodArray<z.ZodString>>]>, z.ZodTransform<string[][], string | string[] | string[][]>>>;
 }, z.core.$strict>;
-type EntityConfig = z.infer<typeof entityConfig>;
+export type EntityConfig = z.infer<typeof entityConfig>;
 declare const timestampConfig: z.ZodObject<{
   names: z.ZodArray<z.ZodString>;
   required: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-type TimestampConfig = z.infer<typeof timestampConfig>;
-declare const config: z.ZodObject<{
+export type TimestampConfig = z.infer<typeof timestampConfig>;
+export declare const config: z.ZodObject<{
   databaseUrl: z.ZodOptional<z.ZodString>;
   contextType: z.ZodOptional<z.ZodString>;
   transactionType: z.ZodOptional<z.ZodString>;
@@ -138,44 +138,44 @@ declare const config: z.ZodObject<{
   codemodVersion: z.ZodDefault<z.ZodNumber>;
   schemas: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-type Config = z.infer<typeof config> & {
+export type Config = z.infer<typeof config> & {
   __tableToEntityName?: Record<string, string>;
 };
-declare const ormMaintainedFields: string[];
+export declare const ormMaintainedFields: string[];
 /** Ensure the user doesn't have any typos in their config. */
-declare function warnInvalidConfigEntries(config: Config, db: DbMetadata): void;
-declare function isGetterField(config: Config, entity: Entity, fieldName: string): boolean;
-declare function isReactiveField(config: Config, entity: Entity, fieldName: string): boolean;
-declare function isReactiveReference(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function warnInvalidConfigEntries(config: Config, db: DbMetadata): void;
+export declare function isGetterField(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isReactiveField(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isReactiveReference(config: Config, entity: Entity, fieldName: string): boolean;
 /** Returns true if this m2m relation is configured as a ReactiveManyToMany (derived: async). */
-declare function isReactiveManyToMany(config: Config, entity: Entity, fieldName: string): boolean;
-declare function isProtected(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isReactiveManyToMany(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isProtected(config: Config, entity: Entity, fieldName: string): boolean;
 /** Whether a column should be excluded from the default SELECT and exposed as a lazy-loaded `LazyField`. */
-declare function isLazyField(config: Config, entity: Entity, fieldName: string): boolean;
-declare function serdeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function superstructConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function zodSchemaConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function fieldTypeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function isLargeCollection(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isLazyField(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function serdeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function superstructConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function zodSchemaConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function fieldTypeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function isLargeCollection(config: Config, entity: Entity, fieldName: string): boolean;
 /** Whether a collection should include (or exclude) soft-deleted entities from `.get`/`.load`. */
-declare function softDeletesConfig(config: Config, entity: Entity, fieldName: string): "include" | "exclude" | undefined;
-declare function isFieldIgnored(config: Config, entity: Entity, fieldName: string, notNull?: boolean, hasDefault?: boolean): boolean;
-declare function isFieldHasDefault(config: Config, entity: Entity, fieldName: string): boolean;
-declare function loadConfig(): Promise<Config>;
+export declare function softDeletesConfig(config: Config, entity: Entity, fieldName: string): "include" | "exclude" | undefined;
+export declare function isFieldIgnored(config: Config, entity: Entity, fieldName: string, notNull?: boolean, hasDefault?: boolean): boolean;
+export declare function isFieldHasDefault(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function loadConfig(): Promise<Config>;
 /**
  * Writes the potentially-updated config entry back to `joist-config.json`.
  *
  * We format the output with prettier so it should both a) look nice and b) be deterministic,
  * such that no changes to the config show up as noops to the scm.
  */
-declare function writeConfig(config: Config): Promise<void>;
-declare function stripStiPlaceholders(config: Config, entities: EntityDbMetadata[]): void;
+export declare function writeConfig(config: Config): Promise<void>;
+export declare function stripStiPlaceholders(config: Config, entities: EntityDbMetadata[]): void;
 /** Applies defaults to the timestamp config. */
-declare function getTimestampConfig(config: Config): {
+export declare function getTimestampConfig(config: Config): {
   updatedAtConf: Required<TimestampConfig>;
   createdAtConf: Required<TimestampConfig>;
   deletedAtConf: Required<TimestampConfig>;
 };
 //#endregion
-export { Config, EntityConfig, FieldConfig, RelationConfig, TimestampConfig, config, fieldTypeConfig, getTimestampConfig, isFieldHasDefault, isFieldIgnored, isGetterField, isLargeCollection, isLazyField, isProtected, isReactiveField, isReactiveManyToMany, isReactiveReference, loadConfig, ormMaintainedFields, serdeConfig, softDeletesConfig, stripStiPlaceholders, superstructConfig, warnInvalidConfigEntries, writeConfig, zodSchemaConfig };
+export {};
 //# sourceMappingURL=config.d.cts.map

package/build/config.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"mappings":";;;cAiBM,aAAW,EAAA;;;;;;;;;;;;;GAmBN,EAAA,KAAA;KAEC,cAAc,EAAE,aAAa;cAEnC,gBAAc,EAAA;;;;;;;;;;;GA8BT,EAAA,KAAA;KAEC,iBAAiB,EAAE,aAAa;cAMtC,cAAY,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWP,EAAA,KAAA;KAEC,eAAe,EAAE,aAAa;cAEpC,iBAAe,EAAA;;;GAOV,EAAA,KAAA;KAEC,kBAAkB,EAAE,aAAa;cAEhC,QAAM,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqER,EAAA,KAAA;KAEC,SAAS,EAAE,aAAa;EAElC,sBAAsB;;cAGX;;iBAGG,yBAAyB,QAAQ,QAAQ,IAAI;iBA2F7C,cAAc,QAAQ,QAAQ,QAAQ,QAAQ;iBAI9C,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIhD,oBAAoB,QAAQ,QAAQ,QAAQ,QAAQ;;iBAKpD,qBAAqB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIrD,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;;iBAK5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;iBAI5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;iBAI5C,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIlD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIhD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIhD,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;;iBAKlD,kBACd,QAAQ,QACR,QAAQ,QACR;iBAKc,eACd,QAAQ,QACR,QAAQ,QACR,mBACA,mBACA;iBAWc,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;iBAQ5C,cAAc,QAAQ;;;;;;;iBA2BtB,YAAY,QAAQ,SAAS;iBAYnC,qBAAqB,QAAQ,QAAQ,UAAU;;iBAY/C,mBAAmB,QAAQ;EACzC,eAAe,SAAS;EACxB,eAAe,SAAS;EACxB,eAAe,SAAS"}
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"mappings":";;;cAiBM,aAAW,EAAA;;;;;;;;;;;;;GAmBN,EAAA,KAAA;YAEC,cAAc,EAAE,aAAa;cAEnC,gBAAc,EAAA;;;;;;;;;;;GA8BT,EAAA,KAAA;YAEC,iBAAiB,EAAE,aAAa;cAMtC,cAAY,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWP,EAAA,KAAA;YAEC,eAAe,EAAE,aAAa;cAEpC,iBAAe,EAAA;;;GAOV,EAAA,KAAA;YAEC,kBAAkB,EAAE,aAAa;qBAEhC,QAAM,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqER,EAAA,KAAA;YAEC,SAAS,EAAE,aAAa;EAElC,sBAAsB;;qBAGX;;wBAGG,yBAAyB,QAAQ,QAAQ,IAAI;wBA2F7C,cAAc,QAAQ,QAAQ,QAAQ,QAAQ;wBAI9C,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIhD,oBAAoB,QAAQ,QAAQ,QAAQ,QAAQ;;wBAKpD,qBAAqB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIrD,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;;wBAK5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;wBAI5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;wBAI5C,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIlD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIhD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIhD,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;;wBAKlD,kBACd,QAAQ,QACR,QAAQ,QACR;wBAKc,eACd,QAAQ,QACR,QAAQ,QACR,mBACA,mBACA;wBAWc,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;wBAQ5C,cAAc,QAAQ;;;;;;;wBA2BtB,YAAY,QAAQ,SAAS;wBAYnC,qBAAqB,QAAQ,QAAQ,UAAU;;wBAY/C,mBAAmB,QAAQ;EACzC,eAAe,SAAS;EACxB,eAAe,SAAS;EACxB,eAAe,SAAS"}

package/build/config.d.mts

@@ -15,7 +15,7 @@ declare const fieldConfig: z.ZodObject<{
   hasDefault: z.ZodOptional<z.ZodBoolean>;
   lazy: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-type FieldConfig = z.infer<typeof fieldConfig>;
+export type FieldConfig = z.infer<typeof fieldConfig>;
 declare const relationConfig: z.ZodObject<{
   derived: z.ZodOptional<z.ZodLiteral<"async">>;
   polymorphic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"notNull">, z.ZodLiteral<true>]>>;
@@ -28,7 +28,7 @@ declare const relationConfig: z.ZodObject<{
   notNull: z.ZodOptional<z.ZodBoolean>;
   hasDefault: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-type RelationConfig = z.infer<typeof relationConfig>;
+export type RelationConfig = z.infer<typeof relationConfig>;
 declare const entityConfig: z.ZodObject<{
   tag: z.ZodString;
   tableName: z.ZodOptional<z.ZodString>;
@@ -62,13 +62,13 @@ declare const entityConfig: z.ZodObject<{
   orderBy: z.ZodOptional<z.ZodString>;
   uniqueBy: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodArray<z.ZodString>>]>, z.ZodTransform<string[][], string | string[] | string[][]>>>;
 }, z.core.$strict>;
-type EntityConfig = z.infer<typeof entityConfig>;
+export type EntityConfig = z.infer<typeof entityConfig>;
 declare const timestampConfig: z.ZodObject<{
   names: z.ZodArray<z.ZodString>;
   required: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-type TimestampConfig = z.infer<typeof timestampConfig>;
-declare const config: z.ZodObject<{
+export type TimestampConfig = z.infer<typeof timestampConfig>;
+export declare const config: z.ZodObject<{
   databaseUrl: z.ZodOptional<z.ZodString>;
   contextType: z.ZodOptional<z.ZodString>;
   transactionType: z.ZodOptional<z.ZodString>;
@@ -138,44 +138,44 @@ declare const config: z.ZodObject<{
   codemodVersion: z.ZodDefault<z.ZodNumber>;
   schemas: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-type Config = z.infer<typeof config> & {
+export type Config = z.infer<typeof config> & {
   __tableToEntityName?: Record<string, string>;
 };
-declare const ormMaintainedFields: string[];
+export declare const ormMaintainedFields: string[];
 /** Ensure the user doesn't have any typos in their config. */
-declare function warnInvalidConfigEntries(config: Config, db: DbMetadata): void;
-declare function isGetterField(config: Config, entity: Entity, fieldName: string): boolean;
-declare function isReactiveField(config: Config, entity: Entity, fieldName: string): boolean;
-declare function isReactiveReference(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function warnInvalidConfigEntries(config: Config, db: DbMetadata): void;
+export declare function isGetterField(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isReactiveField(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isReactiveReference(config: Config, entity: Entity, fieldName: string): boolean;
 /** Returns true if this m2m relation is configured as a ReactiveManyToMany (derived: async). */
-declare function isReactiveManyToMany(config: Config, entity: Entity, fieldName: string): boolean;
-declare function isProtected(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isReactiveManyToMany(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isProtected(config: Config, entity: Entity, fieldName: string): boolean;
 /** Whether a column should be excluded from the default SELECT and exposed as a lazy-loaded `LazyField`. */
-declare function isLazyField(config: Config, entity: Entity, fieldName: string): boolean;
-declare function serdeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function superstructConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function zodSchemaConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function fieldTypeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-declare function isLargeCollection(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function isLazyField(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function serdeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function superstructConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function zodSchemaConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function fieldTypeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
+export declare function isLargeCollection(config: Config, entity: Entity, fieldName: string): boolean;
 /** Whether a collection should include (or exclude) soft-deleted entities from `.get`/`.load`. */
-declare function softDeletesConfig(config: Config, entity: Entity, fieldName: string): "include" | "exclude" | undefined;
-declare function isFieldIgnored(config: Config, entity: Entity, fieldName: string, notNull?: boolean, hasDefault?: boolean): boolean;
-declare function isFieldHasDefault(config: Config, entity: Entity, fieldName: string): boolean;
-declare function loadConfig(): Promise<Config>;
+export declare function softDeletesConfig(config: Config, entity: Entity, fieldName: string): "include" | "exclude" | undefined;
+export declare function isFieldIgnored(config: Config, entity: Entity, fieldName: string, notNull?: boolean, hasDefault?: boolean): boolean;
+export declare function isFieldHasDefault(config: Config, entity: Entity, fieldName: string): boolean;
+export declare function loadConfig(): Promise<Config>;
 /**
  * Writes the potentially-updated config entry back to `joist-config.json`.
  *
  * We format the output with prettier so it should both a) look nice and b) be deterministic,
  * such that no changes to the config show up as noops to the scm.
  */
-declare function writeConfig(config: Config): Promise<void>;
-declare function stripStiPlaceholders(config: Config, entities: EntityDbMetadata[]): void;
+export declare function writeConfig(config: Config): Promise<void>;
+export declare function stripStiPlaceholders(config: Config, entities: EntityDbMetadata[]): void;
 /** Applies defaults to the timestamp config. */
-declare function getTimestampConfig(config: Config): {
+export declare function getTimestampConfig(config: Config): {
   updatedAtConf: Required<TimestampConfig>;
   createdAtConf: Required<TimestampConfig>;
   deletedAtConf: Required<TimestampConfig>;
 };
 //#endregion
-export { Config, EntityConfig, FieldConfig, RelationConfig, TimestampConfig, config, fieldTypeConfig, getTimestampConfig, isFieldHasDefault, isFieldIgnored, isGetterField, isLargeCollection, isLazyField, isProtected, isReactiveField, isReactiveManyToMany, isReactiveReference, loadConfig, ormMaintainedFields, serdeConfig, softDeletesConfig, stripStiPlaceholders, superstructConfig, warnInvalidConfigEntries, writeConfig, zodSchemaConfig };
+export {};
 //# sourceMappingURL=config.d.mts.map

package/build/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"mappings":";;;cAiBM,aAAW,EAAA;;;;;;;;;;;;;GAmBN,EAAA,KAAA;KAEC,cAAc,EAAE,aAAa;cAEnC,gBAAc,EAAA;;;;;;;;;;;GA8BT,EAAA,KAAA;KAEC,iBAAiB,EAAE,aAAa;cAMtC,cAAY,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWP,EAAA,KAAA;KAEC,eAAe,EAAE,aAAa;cAEpC,iBAAe,EAAA;;;GAOV,EAAA,KAAA;KAEC,kBAAkB,EAAE,aAAa;cAEhC,QAAM,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqER,EAAA,KAAA;KAEC,SAAS,EAAE,aAAa;EAElC,sBAAsB;;cAGX;;iBAGG,yBAAyB,QAAQ,QAAQ,IAAI;iBA2F7C,cAAc,QAAQ,QAAQ,QAAQ,QAAQ;iBAI9C,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIhD,oBAAoB,QAAQ,QAAQ,QAAQ,QAAQ;;iBAKpD,qBAAqB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIrD,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;;iBAK5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;iBAI5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;iBAI5C,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIlD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIhD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;iBAIhD,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;;iBAKlD,kBACd,QAAQ,QACR,QAAQ,QACR;iBAKc,eACd,QAAQ,QACR,QAAQ,QACR,mBACA,mBACA;iBAWc,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;iBAQ5C,cAAc,QAAQ;;;;;;;iBA2BtB,YAAY,QAAQ,SAAS;iBAYnC,qBAAqB,QAAQ,QAAQ,UAAU;;iBAY/C,mBAAmB,QAAQ;EACzC,eAAe,SAAS;EACxB,eAAe,SAAS;EACxB,eAAe,SAAS"}
+{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"mappings":";;;cAiBM,aAAW,EAAA;;;;;;;;;;;;;GAmBN,EAAA,KAAA;YAEC,cAAc,EAAE,aAAa;cAEnC,gBAAc,EAAA;;;;;;;;;;;GA8BT,EAAA,KAAA;YAEC,iBAAiB,EAAE,aAAa;cAMtC,cAAY,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWP,EAAA,KAAA;YAEC,eAAe,EAAE,aAAa;cAEpC,iBAAe,EAAA;;;GAOV,EAAA,KAAA;YAEC,kBAAkB,EAAE,aAAa;qBAEhC,QAAM,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqER,EAAA,KAAA;YAEC,SAAS,EAAE,aAAa;EAElC,sBAAsB;;qBAGX;;wBAGG,yBAAyB,QAAQ,QAAQ,IAAI;wBA2F7C,cAAc,QAAQ,QAAQ,QAAQ,QAAQ;wBAI9C,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIhD,oBAAoB,QAAQ,QAAQ,QAAQ,QAAQ;;wBAKpD,qBAAqB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIrD,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;;wBAK5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;wBAI5C,YAAY,QAAQ,QAAQ,QAAQ,QAAQ;wBAI5C,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIlD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIhD,gBAAgB,QAAQ,QAAQ,QAAQ,QAAQ;wBAIhD,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;;wBAKlD,kBACd,QAAQ,QACR,QAAQ,QACR;wBAKc,eACd,QAAQ,QACR,QAAQ,QACR,mBACA,mBACA;wBAWc,kBAAkB,QAAQ,QAAQ,QAAQ,QAAQ;wBAQ5C,cAAc,QAAQ;;;;;;;wBA2BtB,YAAY,QAAQ,SAAS;wBAYnC,qBAAqB,QAAQ,QAAQ,UAAU;;wBAY/C,mBAAmB,QAAQ;EACzC,eAAe,SAAS;EACxB,eAAe,SAAS;EACxB,eAAe,SAAS"}

package/build/docs/cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache.cjs","names":["join","tmpdir","#cachePath","#entries","createHash"],"sources":["../../src/docs/cache.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport { promises as fs } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\n\nconst CACHE_VERSION = 1;\nconst CACHE_DIR = join(tmpdir(), \"joist-codegen-cache\");\n\n/** A tuple of .ts and .md mtimes for an entity, used for caching. */\ninterface CacheEntry {\n  tsMtime: number;\n  mdMtime: number; // -1 when .md doesn't exist\n}\n\n/** The shape of the JSON file we write to disk for caching per-entity file modification times. */\ninterface CacheFile {\n  version: number;\n  entities: Record<string, CacheEntry>;\n}\n\n/** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */\nexport class DocsCache {\n  #entries: Record<string, CacheEntry>;\n  #cachePath: string;\n\n  private constructor(cachePath: string, entries: Record<string, CacheEntry>) {\n    this.#cachePath = cachePath;\n    this.#entries = entries;\n  }\n\n  static async load(): Promise<DocsCache> {\n    const cachePath = getCachePath();\n    try {\n      const raw = JSON.parse(await fs.readFile(cachePath, \"utf-8\")) as CacheFile;\n      if (raw.version === CACHE_VERSION) {\n        return new DocsCache(cachePath, raw.entities);\n      }\n    } catch {\n      // Missing or corrupt — start fresh\n    }\n    return new DocsCache(cachePath, {});\n  }\n\n  /** Returns true if both file mtimes match the cached values (i.e. skip processing). */\n  isUpToDate(entityName: string, tsMtime: number, mdMtime: number): boolean {\n    const cached = this.#entries[entityName];\n    return !!cached && cached.tsMtime === Math.floor(tsMtime) && cached.mdMtime === Math.floor(mdMtime);\n  }\n\n  /** Record the current mtimes for an entity after processing it. */\n  update(entityName: string, tsMtime: number, mdMtime: number): void {\n    this.#entries[entityName] = { tsMtime: Math.floor(tsMtime), mdMtime: Math.floor(mdMtime) };\n  }\n\n  async save(): Promise<void> {\n    const data: CacheFile = { version: CACHE_VERSION, entities: this.#entries };\n    await fs.mkdir(CACHE_DIR, { recursive: true });\n    await fs.writeFile(this.#cachePath, JSON.stringify(data), \"utf-8\");\n  }\n}\n\n/** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */\nexport async function getMtime(filePath: string): Promise<number> {\n  try {\n    return (await fs.stat(filePath)).mtimeMs;\n  } catch {\n    return -1;\n  }\n}\n\nfunction getCachePath(): string {\n  const hash = createHash(\"sha256\").update(process.cwd()).digest(\"hex\").slice(0, 16);\n  return join(CACHE_DIR, `${hash}.json`);\n}\n"],"mappings":";;;;;;AAKA,MAAM,gBAAgB;AACtB,MAAM,aAAA,GAAYA,KAAAA,KAAAA,EAAAA,GAAKC,GAAAA,OAAAA,CAAO,GAAG,qBAAqB;;AAetD,IAAa,YAAb,MAAa,UAAU;CACrB;CACA;CAEA,YAAoB,WAAmB,SAAqC;EAC1E,KAAKC,aAAa;EAClB,KAAKC,WAAW;CAClB;CAEA,aAAa,OAA2B;EACtC,MAAM,YAAY,aAAa;EAC/B,IAAI;GACF,MAAM,MAAM,KAAK,MAAM,MAAM,GAAA,SAAG,SAAS,WAAW,OAAO,CAAC;GAC5D,IAAI,IAAI,YAAY,eAClB,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ;EAEhD,QAAQ,CAER;EACA,OAAO,IAAI,UAAU,WAAW,CAAC,CAAC;CACpC;;CAGA,WAAW,YAAoB,SAAiB,SAA0B;EACxE,MAAM,SAAS,KAAKA,SAAS;EAC7B,OAAO,CAAC,CAAC,UAAU,OAAO,YAAY,KAAK,MAAM,OAAO,KAAK,OAAO,YAAY,KAAK,MAAM,OAAO;CACpG;;CAGA,OAAO,YAAoB,SAAiB,SAAuB;EACjE,KAAKA,SAAS,cAAc;GAAE,SAAS,KAAK,MAAM,OAAO;GAAG,SAAS,KAAK,MAAM,OAAO;EAAE;CAC3F;CAEA,MAAM,OAAsB;EAC1B,MAAM,OAAkB;GAAE,SAAS;GAAe,UAAU,KAAKA;EAAS;EAC1E,MAAM,GAAA,SAAG,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;EAC7C,MAAM,GAAA,SAAG,UAAU,KAAKD,YAAY,KAAK,UAAU,IAAI,GAAG,OAAO;CACnE;AACF;;AAGA,eAAsB,SAAS,UAAmC;CAChE,IAAI;EACF,QAAQ,MAAM,GAAA,SAAG,KAAK,QAAQ,EAAA,CAAG;CACnC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,eAAuB;CAC9B,MAAM,QAAA,GAAOE,OAAAA,WAAAA,CAAW,QAAQ,CAAC,CAAC,OAAO,QAAQ,IAAI,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;CACjF,QAAA,GAAOJ,KAAAA,KAAAA,CAAK,WAAW,GAAG,KAAK,MAAM;AACvC"}
+{"version":3,"file":"cache.cjs","names":["join","tmpdir","createHash"],"sources":["../../src/docs/cache.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport { promises as fs } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\n\nconst CACHE_VERSION = 1;\nconst CACHE_DIR = join(tmpdir(), \"joist-codegen-cache\");\n\n/** A tuple of .ts and .md mtimes for an entity, used for caching. */\ninterface CacheEntry {\n  tsMtime: number;\n  mdMtime: number; // -1 when .md doesn't exist\n}\n\n/** The shape of the JSON file we write to disk for caching per-entity file modification times. */\ninterface CacheFile {\n  version: number;\n  entities: Record<string, CacheEntry>;\n}\n\n/** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */\nexport class DocsCache {\n  #entries: Record<string, CacheEntry>;\n  #cachePath: string;\n\n  private constructor(cachePath: string, entries: Record<string, CacheEntry>) {\n    this.#cachePath = cachePath;\n    this.#entries = entries;\n  }\n\n  static async load(): Promise<DocsCache> {\n    const cachePath = getCachePath();\n    try {\n      const raw = JSON.parse(await fs.readFile(cachePath, \"utf-8\")) as CacheFile;\n      if (raw.version === CACHE_VERSION) {\n        return new DocsCache(cachePath, raw.entities);\n      }\n    } catch {\n      // Missing or corrupt — start fresh\n    }\n    return new DocsCache(cachePath, {});\n  }\n\n  /** Returns true if both file mtimes match the cached values (i.e. skip processing). */\n  isUpToDate(entityName: string, tsMtime: number, mdMtime: number): boolean {\n    const cached = this.#entries[entityName];\n    return !!cached && cached.tsMtime === Math.floor(tsMtime) && cached.mdMtime === Math.floor(mdMtime);\n  }\n\n  /** Record the current mtimes for an entity after processing it. */\n  update(entityName: string, tsMtime: number, mdMtime: number): void {\n    this.#entries[entityName] = { tsMtime: Math.floor(tsMtime), mdMtime: Math.floor(mdMtime) };\n  }\n\n  async save(): Promise<void> {\n    const data: CacheFile = { version: CACHE_VERSION, entities: this.#entries };\n    await fs.mkdir(CACHE_DIR, { recursive: true });\n    await fs.writeFile(this.#cachePath, JSON.stringify(data), \"utf-8\");\n  }\n}\n\n/** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */\nexport async function getMtime(filePath: string): Promise<number> {\n  try {\n    return (await fs.stat(filePath)).mtimeMs;\n  } catch {\n    return -1;\n  }\n}\n\nfunction getCachePath(): string {\n  const hash = createHash(\"sha256\").update(process.cwd()).digest(\"hex\").slice(0, 16);\n  return join(CACHE_DIR, `${hash}.json`);\n}\n"],"mappings":";;;;;;AAKA,MAAM,gBAAgB;AACtB,MAAM,aAAA,GAAYA,KAAAA,KAAAA,EAAAA,GAAKC,GAAAA,OAAAA,CAAO,GAAG,qBAAqB;;AAetD,IAAa,YAAb,MAAa,UAAU;CACrB;CACA;CAEA,YAAoB,WAAmB,SAAqC;EAC1E,KAAK,aAAa;EAClB,KAAK,WAAW;CAClB;CAEA,aAAa,OAA2B;EACtC,MAAM,YAAY,aAAa;EAC/B,IAAI;GACF,MAAM,MAAM,KAAK,MAAM,MAAM,GAAA,SAAG,SAAS,WAAW,OAAO,CAAC;GAC5D,IAAI,IAAI,YAAY,eAClB,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ;EAEhD,QAAQ,CAER;EACA,OAAO,IAAI,UAAU,WAAW,CAAC,CAAC;CACpC;;CAGA,WAAW,YAAoB,SAAiB,SAA0B;EACxE,MAAM,SAAS,KAAK,SAAS;EAC7B,OAAO,CAAC,CAAC,UAAU,OAAO,YAAY,KAAK,MAAM,OAAO,KAAK,OAAO,YAAY,KAAK,MAAM,OAAO;CACpG;;CAGA,OAAO,YAAoB,SAAiB,SAAuB;EACjE,KAAK,SAAS,cAAc;GAAE,SAAS,KAAK,MAAM,OAAO;GAAG,SAAS,KAAK,MAAM,OAAO;EAAE;CAC3F;CAEA,MAAM,OAAsB;EAC1B,MAAM,OAAkB;GAAE,SAAS;GAAe,UAAU,KAAK;EAAS;EAC1E,MAAM,GAAA,SAAG,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;EAC7C,MAAM,GAAA,SAAG,UAAU,KAAK,YAAY,KAAK,UAAU,IAAI,GAAG,OAAO;CACnE;AACF;;AAGA,eAAsB,SAAS,UAAmC;CAChE,IAAI;EACF,QAAQ,MAAM,GAAA,SAAG,KAAK,QAAQ,EAAA,CAAG;CACnC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,eAAuB;CAC9B,MAAM,QAAA,GAAOC,OAAAA,WAAAA,CAAW,QAAQ,CAAC,CAAC,OAAO,QAAQ,IAAI,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;CACjF,QAAA,GAAOF,KAAAA,KAAAA,CAAK,WAAW,GAAG,KAAK,MAAM;AACvC"}

package/build/docs/cache.d.cts

@@ -1,6 +1,6 @@
 //#region src/docs/cache.d.ts
 /** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */
-declare class DocsCache {
+export declare class DocsCache {
   #private;
   private constructor();
   static load(): Promise<DocsCache>;
@@ -11,7 +11,6 @@ declare class DocsCache {
   save(): Promise<void>;
 }
 /** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */
-declare function getMtime(filePath: string): Promise<number>;
+export declare function getMtime(filePath: string): Promise<number>;
 //#endregion
-export { DocsCache, getMtime };
 //# sourceMappingURL=cache.d.cts.map

package/build/docs/cache.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.cts","names":[],"sources":["../../src/docs/cache.ts"],"mappings":";;cAqBa;;UAIJ;SAKM,QAAQ,QAAQ;;EAc7B,WAAW,oBAAoB,iBAAiB;;EAMhD,OAAO,oBAAoB,iBAAiB;EAItC,QAAQ;;;iBAQM,SAAS,mBAAmB"}
+{"version":3,"file":"cache.d.cts","names":[],"sources":["../../src/docs/cache.ts"],"mappings":";;qBAqBa;;UAIJ;SAKM,QAAQ,QAAQ;;EAc7B,WAAW,oBAAoB,iBAAiB;;EAMhD,OAAO,oBAAoB,iBAAiB;EAItC,QAAQ;;;wBAQM,SAAS,mBAAmB"}

package/build/docs/cache.d.mts

@@ -1,6 +1,6 @@
 //#region src/docs/cache.d.ts
 /** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */
-declare class DocsCache {
+export declare class DocsCache {
   #private;
   private constructor();
   static load(): Promise<DocsCache>;
@@ -11,7 +11,6 @@ declare class DocsCache {
   save(): Promise<void>;
 }
 /** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */
-declare function getMtime(filePath: string): Promise<number>;
+export declare function getMtime(filePath: string): Promise<number>;
 //#endregion
-export { DocsCache, getMtime };
 //# sourceMappingURL=cache.d.mts.map

package/build/docs/cache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.mts","names":[],"sources":["../../src/docs/cache.ts"],"mappings":";;cAqBa;;UAIJ;SAKM,QAAQ,QAAQ;;EAc7B,WAAW,oBAAoB,iBAAiB;;EAMhD,OAAO,oBAAoB,iBAAiB;EAItC,QAAQ;;;iBAQM,SAAS,mBAAmB"}
+{"version":3,"file":"cache.d.mts","names":[],"sources":["../../src/docs/cache.ts"],"mappings":";;qBAqBa;;UAIJ;SAKM,QAAQ,QAAQ;;EAc7B,WAAW,oBAAoB,iBAAiB;;EAMhD,OAAO,oBAAoB,iBAAiB;EAItC,QAAQ;;;wBAQM,SAAS,mBAAmB"}

package/build/docs/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","names":["#cachePath","#entries","fs"],"sources":["../../src/docs/cache.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport { promises as fs } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\n\nconst CACHE_VERSION = 1;\nconst CACHE_DIR = join(tmpdir(), \"joist-codegen-cache\");\n\n/** A tuple of .ts and .md mtimes for an entity, used for caching. */\ninterface CacheEntry {\n  tsMtime: number;\n  mdMtime: number; // -1 when .md doesn't exist\n}\n\n/** The shape of the JSON file we write to disk for caching per-entity file modification times. */\ninterface CacheFile {\n  version: number;\n  entities: Record<string, CacheEntry>;\n}\n\n/** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */\nexport class DocsCache {\n  #entries: Record<string, CacheEntry>;\n  #cachePath: string;\n\n  private constructor(cachePath: string, entries: Record<string, CacheEntry>) {\n    this.#cachePath = cachePath;\n    this.#entries = entries;\n  }\n\n  static async load(): Promise<DocsCache> {\n    const cachePath = getCachePath();\n    try {\n      const raw = JSON.parse(await fs.readFile(cachePath, \"utf-8\")) as CacheFile;\n      if (raw.version === CACHE_VERSION) {\n        return new DocsCache(cachePath, raw.entities);\n      }\n    } catch {\n      // Missing or corrupt — start fresh\n    }\n    return new DocsCache(cachePath, {});\n  }\n\n  /** Returns true if both file mtimes match the cached values (i.e. skip processing). */\n  isUpToDate(entityName: string, tsMtime: number, mdMtime: number): boolean {\n    const cached = this.#entries[entityName];\n    return !!cached && cached.tsMtime === Math.floor(tsMtime) && cached.mdMtime === Math.floor(mdMtime);\n  }\n\n  /** Record the current mtimes for an entity after processing it. */\n  update(entityName: string, tsMtime: number, mdMtime: number): void {\n    this.#entries[entityName] = { tsMtime: Math.floor(tsMtime), mdMtime: Math.floor(mdMtime) };\n  }\n\n  async save(): Promise<void> {\n    const data: CacheFile = { version: CACHE_VERSION, entities: this.#entries };\n    await fs.mkdir(CACHE_DIR, { recursive: true });\n    await fs.writeFile(this.#cachePath, JSON.stringify(data), \"utf-8\");\n  }\n}\n\n/** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */\nexport async function getMtime(filePath: string): Promise<number> {\n  try {\n    return (await fs.stat(filePath)).mtimeMs;\n  } catch {\n    return -1;\n  }\n}\n\nfunction getCachePath(): string {\n  const hash = createHash(\"sha256\").update(process.cwd()).digest(\"hex\").slice(0, 16);\n  return join(CACHE_DIR, `${hash}.json`);\n}\n"],"mappings":";;;;;AAKA,MAAM,gBAAgB;AACtB,MAAM,YAAY,KAAK,OAAO,GAAG,qBAAqB;;AAetD,IAAa,YAAb,MAAa,UAAU;CACrB;CACA;CAEA,YAAoB,WAAmB,SAAqC;EAC1E,KAAKA,aAAa;EAClB,KAAKC,WAAW;CAClB;CAEA,aAAa,OAA2B;EACtC,MAAM,YAAY,aAAa;EAC/B,IAAI;GACF,MAAM,MAAM,KAAK,MAAM,MAAMC,SAAG,SAAS,WAAW,OAAO,CAAC;GAC5D,IAAI,IAAI,YAAY,eAClB,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ;EAEhD,QAAQ,CAER;EACA,OAAO,IAAI,UAAU,WAAW,CAAC,CAAC;CACpC;;CAGA,WAAW,YAAoB,SAAiB,SAA0B;EACxE,MAAM,SAAS,KAAKD,SAAS;EAC7B,OAAO,CAAC,CAAC,UAAU,OAAO,YAAY,KAAK,MAAM,OAAO,KAAK,OAAO,YAAY,KAAK,MAAM,OAAO;CACpG;;CAGA,OAAO,YAAoB,SAAiB,SAAuB;EACjE,KAAKA,SAAS,cAAc;GAAE,SAAS,KAAK,MAAM,OAAO;GAAG,SAAS,KAAK,MAAM,OAAO;EAAE;CAC3F;CAEA,MAAM,OAAsB;EAC1B,MAAM,OAAkB;GAAE,SAAS;GAAe,UAAU,KAAKA;EAAS;EAC1E,MAAMC,SAAG,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;EAC7C,MAAMA,SAAG,UAAU,KAAKF,YAAY,KAAK,UAAU,IAAI,GAAG,OAAO;CACnE;AACF;;AAGA,eAAsB,SAAS,UAAmC;CAChE,IAAI;EACF,QAAQ,MAAME,SAAG,KAAK,QAAQ,EAAA,CAAG;CACnC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,eAAuB;CAC9B,MAAM,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,QAAQ,IAAI,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;CACjF,OAAO,KAAK,WAAW,GAAG,KAAK,MAAM;AACvC"}
+{"version":3,"file":"cache.js","names":["fs"],"sources":["../../src/docs/cache.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport { promises as fs } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\n\nconst CACHE_VERSION = 1;\nconst CACHE_DIR = join(tmpdir(), \"joist-codegen-cache\");\n\n/** A tuple of .ts and .md mtimes for an entity, used for caching. */\ninterface CacheEntry {\n  tsMtime: number;\n  mdMtime: number; // -1 when .md doesn't exist\n}\n\n/** The shape of the JSON file we write to disk for caching per-entity file modification times. */\ninterface CacheFile {\n  version: number;\n  entities: Record<string, CacheEntry>;\n}\n\n/** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */\nexport class DocsCache {\n  #entries: Record<string, CacheEntry>;\n  #cachePath: string;\n\n  private constructor(cachePath: string, entries: Record<string, CacheEntry>) {\n    this.#cachePath = cachePath;\n    this.#entries = entries;\n  }\n\n  static async load(): Promise<DocsCache> {\n    const cachePath = getCachePath();\n    try {\n      const raw = JSON.parse(await fs.readFile(cachePath, \"utf-8\")) as CacheFile;\n      if (raw.version === CACHE_VERSION) {\n        return new DocsCache(cachePath, raw.entities);\n      }\n    } catch {\n      // Missing or corrupt — start fresh\n    }\n    return new DocsCache(cachePath, {});\n  }\n\n  /** Returns true if both file mtimes match the cached values (i.e. skip processing). */\n  isUpToDate(entityName: string, tsMtime: number, mdMtime: number): boolean {\n    const cached = this.#entries[entityName];\n    return !!cached && cached.tsMtime === Math.floor(tsMtime) && cached.mdMtime === Math.floor(mdMtime);\n  }\n\n  /** Record the current mtimes for an entity after processing it. */\n  update(entityName: string, tsMtime: number, mdMtime: number): void {\n    this.#entries[entityName] = { tsMtime: Math.floor(tsMtime), mdMtime: Math.floor(mdMtime) };\n  }\n\n  async save(): Promise<void> {\n    const data: CacheFile = { version: CACHE_VERSION, entities: this.#entries };\n    await fs.mkdir(CACHE_DIR, { recursive: true });\n    await fs.writeFile(this.#cachePath, JSON.stringify(data), \"utf-8\");\n  }\n}\n\n/** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */\nexport async function getMtime(filePath: string): Promise<number> {\n  try {\n    return (await fs.stat(filePath)).mtimeMs;\n  } catch {\n    return -1;\n  }\n}\n\nfunction getCachePath(): string {\n  const hash = createHash(\"sha256\").update(process.cwd()).digest(\"hex\").slice(0, 16);\n  return join(CACHE_DIR, `${hash}.json`);\n}\n"],"mappings":";;;;;AAKA,MAAM,gBAAgB;AACtB,MAAM,YAAY,KAAK,OAAO,GAAG,qBAAqB;;AAetD,IAAa,YAAb,MAAa,UAAU;CACrB;CACA;CAEA,YAAoB,WAAmB,SAAqC;EAC1E,KAAK,aAAa;EAClB,KAAK,WAAW;CAClB;CAEA,aAAa,OAA2B;EACtC,MAAM,YAAY,aAAa;EAC/B,IAAI;GACF,MAAM,MAAM,KAAK,MAAM,MAAMA,SAAG,SAAS,WAAW,OAAO,CAAC;GAC5D,IAAI,IAAI,YAAY,eAClB,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ;EAEhD,QAAQ,CAER;EACA,OAAO,IAAI,UAAU,WAAW,CAAC,CAAC;CACpC;;CAGA,WAAW,YAAoB,SAAiB,SAA0B;EACxE,MAAM,SAAS,KAAK,SAAS;EAC7B,OAAO,CAAC,CAAC,UAAU,OAAO,YAAY,KAAK,MAAM,OAAO,KAAK,OAAO,YAAY,KAAK,MAAM,OAAO;CACpG;;CAGA,OAAO,YAAoB,SAAiB,SAAuB;EACjE,KAAK,SAAS,cAAc;GAAE,SAAS,KAAK,MAAM,OAAO;GAAG,SAAS,KAAK,MAAM,OAAO;EAAE;CAC3F;CAEA,MAAM,OAAsB;EAC1B,MAAM,OAAkB;GAAE,SAAS;GAAe,UAAU,KAAK;EAAS;EAC1E,MAAMA,SAAG,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;EAC7C,MAAMA,SAAG,UAAU,KAAK,YAAY,KAAK,UAAU,IAAI,GAAG,OAAO;CACnE;AACF;;AAGA,eAAsB,SAAS,UAAmC;CAChE,IAAI;EACF,QAAQ,MAAMA,SAAG,KAAK,QAAQ,EAAA,CAAG;CACnC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,eAAuB;CAC9B,MAAM,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,QAAQ,IAAI,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;CACjF,OAAO,KAAK,WAAW,GAAG,KAAK,MAAM;AACvC"}

package/build/docs/generate-metadata-docs.d.cts

@@ -3,7 +3,6 @@ import { ParsedDoc } from "./markdown.cjs";
 import { CodegenFile } from "ts-poet";
 //#region src/docs/generate-metadata-docs.d.ts
 /** Creates the `metadata-docs.ts` runtime artifact to access docs. */
-declare function generateMetadataDocsFile(dbMeta: DbMetadata, docsByEntity: Record<string, ParsedDoc>): CodegenFile;
+export declare function generateMetadataDocsFile(dbMeta: DbMetadata, docsByEntity: Record<string, ParsedDoc>): CodegenFile;
 //#endregion
-export { generateMetadataDocsFile };
 //# sourceMappingURL=generate-metadata-docs.d.cts.map

package/build/docs/generate-metadata-docs.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-metadata-docs.d.cts","names":[],"sources":["../../src/docs/generate-metadata-docs.ts"],"mappings":";;;;;iBAMgB,yBAAyB,QAAQ,YAAY,cAAc,eAAe,aAAa"}
+{"version":3,"file":"generate-metadata-docs.d.cts","names":[],"sources":["../../src/docs/generate-metadata-docs.ts"],"mappings":";;;;;wBAMgB,yBAAyB,QAAQ,YAAY,cAAc,eAAe,aAAa"}

package/build/docs/generate-metadata-docs.d.mts

@@ -3,7 +3,6 @@ import { ParsedDoc } from "./markdown.mjs";
 import { CodegenFile } from "ts-poet";
 //#region src/docs/generate-metadata-docs.d.ts
 /** Creates the `metadata-docs.ts` runtime artifact to access docs. */
-declare function generateMetadataDocsFile(dbMeta: DbMetadata, docsByEntity: Record<string, ParsedDoc>): CodegenFile;
+export declare function generateMetadataDocsFile(dbMeta: DbMetadata, docsByEntity: Record<string, ParsedDoc>): CodegenFile;
 //#endregion
-export { generateMetadataDocsFile };
 //# sourceMappingURL=generate-metadata-docs.d.mts.map

package/build/docs/generate-metadata-docs.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-metadata-docs.d.mts","names":[],"sources":["../../src/docs/generate-metadata-docs.ts"],"mappings":";;;;;iBAMgB,yBAAyB,QAAQ,YAAY,cAAc,eAAe,aAAa"}
+{"version":3,"file":"generate-metadata-docs.d.mts","names":[],"sources":["../../src/docs/generate-metadata-docs.ts"],"mappings":";;;;;wBAMgB,yBAAyB,QAAQ,YAAY,cAAc,eAAe,aAAa"}

package/build/docs/index.d.cts

@@ -3,14 +3,14 @@ import { generateMetadataDocsFile } from "./generate-metadata-docs.cjs";
 import { buildJSDocBlock, generatedTag } from "./parsing.cjs";
 //#region src/docs/index.d.ts
 /** Loads each entity's parsed `.md` doc, i.e. for injecting into codegen JSDocs & runtime metadata. */
-declare function loadEntityDocs(entitiesDir: string, entityNames: string[]): Promise<Record<string, ParsedDoc>>;
+export declare function loadEntityDocs(entitiesDir: string, entityNames: string[]): Promise<Record<string, ParsedDoc>>;
 /**
  * Run the full docs sync pipeline with mtime-based caching:
  * 1. backfill .md from .ts JSDocs
  * 2. sync .md back into .ts JSDocs
  * 3. save the cache
  */
-declare function syncDocs(entitiesDir: string, entityNames: string[]): Promise<void>;
+export declare function syncDocs(entitiesDir: string, entityNames: string[]): Promise<void>;
 //#endregion
-export { type ParsedDoc, buildJSDocBlock, generateMetadataDocsFile, generatedTag, loadEntityDocs, syncDocs };
+export { type ParsedDoc, buildJSDocBlock, generateMetadataDocsFile, generatedTag };
 //# sourceMappingURL=index.d.cts.map

package/build/docs/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/docs/index.ts"],"mappings":";;;;;iBAWsB,eAAe,qBAAqB,wBAAwB,QAAQ,eAAe;;;;;;;iBAiBnF,SAAS,qBAAqB,wBAAwB"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/docs/index.ts"],"mappings":";;;;;wBAWsB,eAAe,qBAAqB,wBAAwB,QAAQ,eAAe;;;;;;;wBAiBnF,SAAS,qBAAqB,wBAAwB"}

package/build/docs/index.d.mts

@@ -3,14 +3,14 @@ import { generateMetadataDocsFile } from "./generate-metadata-docs.mjs";
 import { buildJSDocBlock, generatedTag } from "./parsing.mjs";
 //#region src/docs/index.d.ts
 /** Loads each entity's parsed `.md` doc, i.e. for injecting into codegen JSDocs & runtime metadata. */
-declare function loadEntityDocs(entitiesDir: string, entityNames: string[]): Promise<Record<string, ParsedDoc>>;
+export declare function loadEntityDocs(entitiesDir: string, entityNames: string[]): Promise<Record<string, ParsedDoc>>;
 /**
  * Run the full docs sync pipeline with mtime-based caching:
  * 1. backfill .md from .ts JSDocs
  * 2. sync .md back into .ts JSDocs
  * 3. save the cache
  */
-declare function syncDocs(entitiesDir: string, entityNames: string[]): Promise<void>;
+export declare function syncDocs(entitiesDir: string, entityNames: string[]): Promise<void>;
 //#endregion
-export { type ParsedDoc, buildJSDocBlock, generateMetadataDocsFile, generatedTag, loadEntityDocs, syncDocs };
+export { type ParsedDoc, buildJSDocBlock, generateMetadataDocsFile, generatedTag };
 //# sourceMappingURL=index.d.mts.map

package/build/docs/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/docs/index.ts"],"mappings":";;;;;iBAWsB,eAAe,qBAAqB,wBAAwB,QAAQ,eAAe;;;;;;;iBAiBnF,SAAS,qBAAqB,wBAAwB"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/docs/index.ts"],"mappings":";;;;;wBAWsB,eAAe,qBAAqB,wBAAwB,QAAQ,eAAe;;;;;;;wBAiBnF,SAAS,qBAAqB,wBAAwB"}

package/build/docs/markdown.d.cts

@@ -1,20 +1,20 @@
 //#region src/docs/markdown.d.ts
-interface ParsedDoc {
+export interface ParsedDoc {
   overview: string;
   fields: Record<string, string>;
 }
 /** Read and parse a .md file if it exists, returning undefined if it doesn't. */
-declare function maybeReadMarkdownFile(filePath: string): Promise<ParsedDoc | undefined>;
+export declare function maybeReadMarkdownFile(filePath: string): Promise<ParsedDoc | undefined>;
 /** Reads a basic `overview` and per-field docs out of md content. */
-declare function parseMarkdownContent(content: string): ParsedDoc;
+export declare function parseMarkdownContent(content: string): ParsedDoc;
 /** Create a new .md file from scratch (used only for initial backfill when no .md exists). */
-declare function writeMarkdownDoc(filePath: string, overview: string, fields?: Record<string, string>): Promise<void>;
+export declare function writeMarkdownDoc(filePath: string, overview: string, fields?: Record<string, string>): Promise<void>;
 /**
  * Update an existing .md file, merging in new/changed content without stomping user content.
  * If the file doesn't exist, creates it from scratch.
  */
-declare function updateMarkdownDoc(filePath: string, overview: string | undefined, fields: Record<string, string>): Promise<void>;
-declare function getMarkdownFilePath(entitiesDir: string, entityName: string): string;
+export declare function updateMarkdownDoc(filePath: string, overview: string | undefined, fields: Record<string, string>): Promise<void>;
+export declare function getMarkdownFilePath(entitiesDir: string, entityName: string): string;
 /**
  * Merge updates into an existing .md file, preserving all user content.
  *
@@ -24,9 +24,9 @@ declare function getMarkdownFilePath(entitiesDir: string, entityName: string): s
  * - All other content (custom sections, tables, etc.) is preserved verbatim
  */
 declare function mergeMarkdownContent(existing: string, overview: string | undefined, fields: Record<string, string>): string;
-declare const testing: {
+export declare const testing: {
   mergeMarkdownContent: typeof mergeMarkdownContent;
 };
 //#endregion
-export { ParsedDoc, getMarkdownFilePath, maybeReadMarkdownFile, parseMarkdownContent, testing, updateMarkdownDoc, writeMarkdownDoc };
+export {};
 //# sourceMappingURL=markdown.d.cts.map

package/build/docs/markdown.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.cts","names":[],"sources":["../../src/docs/markdown.ts"],"mappings":";UAKiB;EACf;EACA,QAAQ;;;iBAIY,sBAAsB,mBAAmB,QAAQ;;iBAUvD,qBAAqB,kBAAkB;;iBAiDjC,iBACpB,kBACA,kBACA,SAAS,yBACR;;;;;iBAgCmB,kBACpB,kBACA,8BACA,QAAQ,yBACP;iBAkBa,oBAAoB,qBAAqB;;;;;;;;;iBAqBhD,qBAAqB,kBAAkB,8BAA8B,QAAQ;cA+EzE;+BAAA"}
+{"version":3,"file":"markdown.d.cts","names":[],"sources":["../../src/docs/markdown.ts"],"mappings":";iBAKiB;EACf;EACA,QAAQ;;;wBAIY,sBAAsB,mBAAmB,QAAQ;;wBAUvD,qBAAqB,kBAAkB;;wBAiDjC,iBACpB,kBACA,kBACA,SAAS,yBACR;;;;;wBAgCmB,kBACpB,kBACA,8BACA,QAAQ,yBACP;wBAkBa,oBAAoB,qBAAqB;;;;;;;;;iBAqBhD,qBAAqB,kBAAkB,8BAA8B,QAAQ;qBA+EzE;+BAAA"}

package/build/docs/markdown.d.mts

@@ -1,20 +1,20 @@
 //#region src/docs/markdown.d.ts
-interface ParsedDoc {
+export interface ParsedDoc {
   overview: string;
   fields: Record<string, string>;
 }
 /** Read and parse a .md file if it exists, returning undefined if it doesn't. */
-declare function maybeReadMarkdownFile(filePath: string): Promise<ParsedDoc | undefined>;
+export declare function maybeReadMarkdownFile(filePath: string): Promise<ParsedDoc | undefined>;
 /** Reads a basic `overview` and per-field docs out of md content. */
-declare function parseMarkdownContent(content: string): ParsedDoc;
+export declare function parseMarkdownContent(content: string): ParsedDoc;
 /** Create a new .md file from scratch (used only for initial backfill when no .md exists). */
-declare function writeMarkdownDoc(filePath: string, overview: string, fields?: Record<string, string>): Promise<void>;
+export declare function writeMarkdownDoc(filePath: string, overview: string, fields?: Record<string, string>): Promise<void>;
 /**
  * Update an existing .md file, merging in new/changed content without stomping user content.
  * If the file doesn't exist, creates it from scratch.
  */
-declare function updateMarkdownDoc(filePath: string, overview: string | undefined, fields: Record<string, string>): Promise<void>;
-declare function getMarkdownFilePath(entitiesDir: string, entityName: string): string;
+export declare function updateMarkdownDoc(filePath: string, overview: string | undefined, fields: Record<string, string>): Promise<void>;
+export declare function getMarkdownFilePath(entitiesDir: string, entityName: string): string;
 /**
  * Merge updates into an existing .md file, preserving all user content.
  *
@@ -24,9 +24,9 @@ declare function getMarkdownFilePath(entitiesDir: string, entityName: string): s
  * - All other content (custom sections, tables, etc.) is preserved verbatim
  */
 declare function mergeMarkdownContent(existing: string, overview: string | undefined, fields: Record<string, string>): string;
-declare const testing: {
+export declare const testing: {
   mergeMarkdownContent: typeof mergeMarkdownContent;
 };
 //#endregion
-export { ParsedDoc, getMarkdownFilePath, maybeReadMarkdownFile, parseMarkdownContent, testing, updateMarkdownDoc, writeMarkdownDoc };
+export {};
 //# sourceMappingURL=markdown.d.mts.map

package/build/docs/markdown.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.mts","names":[],"sources":["../../src/docs/markdown.ts"],"mappings":";UAKiB;EACf;EACA,QAAQ;;;iBAIY,sBAAsB,mBAAmB,QAAQ;;iBAUvD,qBAAqB,kBAAkB;;iBAiDjC,iBACpB,kBACA,kBACA,SAAS,yBACR;;;;;iBAgCmB,kBACpB,kBACA,8BACA,QAAQ,yBACP;iBAkBa,oBAAoB,qBAAqB;;;;;;;;;iBAqBhD,qBAAqB,kBAAkB,8BAA8B,QAAQ;cA+EzE;+BAAA"}
+{"version":3,"file":"markdown.d.mts","names":[],"sources":["../../src/docs/markdown.ts"],"mappings":";iBAKiB;EACf;EACA,QAAQ;;;wBAIY,sBAAsB,mBAAmB,QAAQ;;wBAUvD,qBAAqB,kBAAkB;;wBAiDjC,iBACpB,kBACA,kBACA,SAAS,yBACR;;;;;wBAgCmB,kBACpB,kBACA,8BACA,QAAQ,yBACP;wBAkBa,oBAAoB,qBAAqB;;;;;;;;;iBAqBhD,qBAAqB,kBAAkB,8BAA8B,QAAQ;qBA+EzE;+BAAA"}

package/build/docs/parsing.d.cts

@@ -11,20 +11,20 @@ type Commented = ASTNode & {
   end?: number;
   loc?: namedTypes.SourceLocation | null;
 };
-type MemberKind = "property" | "getter" | "setter" | "method";
-interface MemberInfo {
+export type MemberKind = "property" | "getter" | "setter" | "method";
+export interface MemberInfo {
   kind: MemberKind;
   name: string;
   doc: string | undefined;
   node: Commented;
 }
-interface SourceEdit {
+export interface SourceEdit {
   start: number;
   end: number;
   text: string;
 }
 /** Parse an entity .ts file and extract class + member JSDoc. */
-declare function parseEntityJSDocs(source: string): {
+export declare function parseEntityJSDocs(source: string): {
   classDoc: string | undefined;
   classNode: Commented | undefined;
   members: MemberInfo[];
@@ -36,13 +36,13 @@ declare function parseEntityJSDocs(source: string): {
  * (This is bizarre, but this `SourceEdit` + `applyEdits` leaves all existing formatting
  * alone better than doing a `node.toSource()` or other AST-based updates. :grimmacing:)
  */
-declare function buildJSDocEdit(node: Commented, text: string): SourceEdit;
+export declare function buildJSDocEdit(node: Commented, text: string): SourceEdit;
 /** Apply edits to source by splicing in reverse order. */
-declare function applyEdits(source: string, edits: SourceEdit[]): string;
+export declare function applyEdits(source: string, edits: SourceEdit[]): string;
 /** Build a JSDoc block comment string from plain text. */
-declare function buildJSDocBlock(text: string, indent: number): string;
+export declare function buildJSDocBlock(text: string, indent: number): string;
 /** The `@generated Entity.md` marker, i.e. so readers know a JSDoc is sourced from (and edited in) the `.md`. */
-declare function generatedTag(entityName: string): string;
+export declare function generatedTag(entityName: string): string;
 //#endregion
-export { MemberInfo, MemberKind, SourceEdit, applyEdits, buildJSDocBlock, buildJSDocEdit, generatedTag, parseEntityJSDocs };
+export {};
 //# sourceMappingURL=parsing.d.cts.map

package/build/docs/parsing.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"parsing.d.cts","names":[],"sources":["../../src/docs/parsing.ts"],"mappings":";;;KAKK,eAAe,WAAW,eAAe,WAAW,cAAc,WAAW,QAAQ,WAAW;EACnG;EACA;;KAGG,YAAY;EACf,WAAW;EACX;EACA;EACA,MAAM,WAAW;;KAGP;UAEK;EACf,MAAM;EACN;EACA;EACA,MAAM;;UAGS;EACf;EACA;EACA;;;iBAIc,kBAAkB;;;;;;;;;;;;iBAuDlB,eAAe,MAAM,WAAW,eAAe;;iBAW/C,WAAW,gBAAgB,OAAO;;iBAUlC,gBAAgB,cAAc;;iBAQ9B,aAAa"}
+{"version":3,"file":"parsing.d.cts","names":[],"sources":["../../src/docs/parsing.ts"],"mappings":";;;KAKK,eAAe,WAAW,eAAe,WAAW,cAAc,WAAW,QAAQ,WAAW;EACnG;EACA;;KAGG,YAAY;EACf,WAAW;EACX;EACA;EACA,MAAM,WAAW;;YAGP;iBAEK;EACf,MAAM;EACN;EACA;EACA,MAAM;;iBAGS;EACf;EACA;EACA;;;wBAIc,kBAAkB;;;;;;;;;;;;wBAuDlB,eAAe,MAAM,WAAW,eAAe;;wBAW/C,WAAW,gBAAgB,OAAO;;wBAUlC,gBAAgB,cAAc;;wBAQ9B,aAAa"}

package/build/docs/parsing.d.mts

@@ -11,20 +11,20 @@ type Commented = ASTNode & {
   end?: number;
   loc?: namedTypes.SourceLocation | null;
 };
-type MemberKind = "property" | "getter" | "setter" | "method";
-interface MemberInfo {
+export type MemberKind = "property" | "getter" | "setter" | "method";
+export interface MemberInfo {
   kind: MemberKind;
   name: string;
   doc: string | undefined;
   node: Commented;
 }
-interface SourceEdit {
+export interface SourceEdit {
   start: number;
   end: number;
   text: string;
 }
 /** Parse an entity .ts file and extract class + member JSDoc. */
-declare function parseEntityJSDocs(source: string): {
+export declare function parseEntityJSDocs(source: string): {
   classDoc: string | undefined;
   classNode: Commented | undefined;
   members: MemberInfo[];
@@ -36,13 +36,13 @@ declare function parseEntityJSDocs(source: string): {
  * (This is bizarre, but this `SourceEdit` + `applyEdits` leaves all existing formatting
  * alone better than doing a `node.toSource()` or other AST-based updates. :grimmacing:)
  */
-declare function buildJSDocEdit(node: Commented, text: string): SourceEdit;
+export declare function buildJSDocEdit(node: Commented, text: string): SourceEdit;
 /** Apply edits to source by splicing in reverse order. */
-declare function applyEdits(source: string, edits: SourceEdit[]): string;
+export declare function applyEdits(source: string, edits: SourceEdit[]): string;
 /** Build a JSDoc block comment string from plain text. */
-declare function buildJSDocBlock(text: string, indent: number): string;
+export declare function buildJSDocBlock(text: string, indent: number): string;
 /** The `@generated Entity.md` marker, i.e. so readers know a JSDoc is sourced from (and edited in) the `.md`. */
-declare function generatedTag(entityName: string): string;
+export declare function generatedTag(entityName: string): string;
 //#endregion
-export { MemberInfo, MemberKind, SourceEdit, applyEdits, buildJSDocBlock, buildJSDocEdit, generatedTag, parseEntityJSDocs };
+export {};
 //# sourceMappingURL=parsing.d.mts.map

package/build/docs/parsing.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"parsing.d.mts","names":[],"sources":["../../src/docs/parsing.ts"],"mappings":";;;KAKK,eAAe,WAAW,eAAe,WAAW,cAAc,WAAW,QAAQ,WAAW;EACnG;EACA;;KAGG,YAAY;EACf,WAAW;EACX;EACA;EACA,MAAM,WAAW;;KAGP;UAEK;EACf,MAAM;EACN;EACA;EACA,MAAM;;UAGS;EACf;EACA;EACA;;;iBAIc,kBAAkB;;;;;;;;;;;;iBAuDlB,eAAe,MAAM,WAAW,eAAe;;iBAW/C,WAAW,gBAAgB,OAAO;;iBAUlC,gBAAgB,cAAc;;iBAQ9B,aAAa"}
+{"version":3,"file":"parsing.d.mts","names":[],"sources":["../../src/docs/parsing.ts"],"mappings":";;;KAKK,eAAe,WAAW,eAAe,WAAW,cAAc,WAAW,QAAQ,WAAW;EACnG;EACA;;KAGG,YAAY;EACf,WAAW;EACX;EACA;EACA,MAAM,WAAW;;YAGP;iBAEK;EACf,MAAM;EACN;EACA;EACA,MAAM;;iBAGS;EACf;EACA;EACA;;;wBAIc,kBAAkB;;;;;;;;;;;;wBAuDlB,eAAe,MAAM,WAAW,eAAe;;wBAW/C,WAAW,gBAAgB,OAAO;;wBAUlC,gBAAgB,cAAc;;wBAQ9B,aAAa"}

package/build/findEntityScopes.d.cts

@@ -2,13 +2,12 @@ import { Config } from "./config.cjs";
 import { Entity } from "./EntityDbMetadata.cjs";
 //#region src/findEntityScopes.d.ts
 /** Each `static active = ...` scope in an entity. */
-interface ScopeMember {
+export interface ScopeMember {
   name: string;
   type: string;
 }
-type ScopeMembersByEntity = Record<string, ScopeMember[]>;
+export type ScopeMembersByEntity = Record<string, ScopeMember[]>;
 /** Finds static scope declarations for all entity files. */
-declare function findAllEntityScopes(config: Config, entities: Entity[]): Promise<ScopeMembersByEntity>;
+export declare function findAllEntityScopes(config: Config, entities: Entity[]): Promise<ScopeMembersByEntity>;
 //#endregion
-export { ScopeMember, ScopeMembersByEntity, findAllEntityScopes };
 //# sourceMappingURL=findEntityScopes.d.cts.map

package/build/findEntityScopes.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"findEntityScopes.d.cts","names":[],"sources":["../src/findEntityScopes.ts"],"mappings":";;;;UAiBiB;EAEf;EAEA;;KAGU,uBAAuB,eAAe;;iBAG5B,oBAAoB,QAAQ,QAAQ,UAAU,WAAW,QAAQ"}
+{"version":3,"file":"findEntityScopes.d.cts","names":[],"sources":["../src/findEntityScopes.ts"],"mappings":";;;;iBAiBiB;EAEf;EAEA;;YAGU,uBAAuB,eAAe;;wBAG5B,oBAAoB,QAAQ,QAAQ,UAAU,WAAW,QAAQ"}