@astryxdesign/cli 0.6.3-canary.ea2f048 → 0.6.3-canary.ebaebc4

package/authoring/codemod/parse.d.mts

@@ -5,8 +5,8 @@
  * Compile-time drift-lock: sealed envelope must infer exactly the public
  * stamped-codemod union.
  *
- * @typedef {import('../_shared/contract').Expect<
- *   import('../_shared/contract').Equal<
+ * @typedef {import('../_shared/contract.js').Expect<
+ *   import('../_shared/contract.js').Equal<
  *     z.infer<typeof codemodEnvelopeSchema>,
  *     AstryxCodemod | AstryxConfigCodemod
  *   >
@@ -24,10 +24,10 @@ export function parseCodemod(input: unknown, label?: string): AstryxCodemod | As
  * Compile-time drift-lock: sealed envelope must infer exactly the public
  * stamped-codemod union.
  */
-export type _CodemodDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").Equal<z.infer<typeof codemodEnvelopeSchema>, AstryxCodemod | AstryxConfigCodemod>>;
-export type AstryxCodemod = import("./type").AstryxCodemod;
-export type AstryxConfigCodemod = import("./type").AstryxConfigCodemod;
-export type AstryxCodemodTransform = import("./type").AstryxCodemodTransform;
+export type _CodemodDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof codemodEnvelopeSchema>, AstryxCodemod | AstryxConfigCodemod>>;
+export type AstryxCodemod = import("./type.js").AstryxCodemod;
+export type AstryxConfigCodemod = import("./type.js").AstryxConfigCodemod;
+export type AstryxCodemodTransform = import("./type.js").AstryxCodemodTransform;
 import { z } from 'zod';
 /**
  * The load-boundary contract: a stamped codemod default export, discriminated
@@ -38,13 +38,13 @@ declare const codemodEnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     isOptional: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     fileExtensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    transform: z.ZodType<import("./type").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type").AstryxCodemodTransform, any>>;
+    transform: z.ZodType<import("./type.js").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type.js").AstryxCodemodTransform, any>>;
     type: z.ZodLiteral<"code">;
 }, z.core.$strict>, z.ZodObject<{
     title: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     isOptional: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    transform: z.ZodType<import("./type").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type").AstryxCodemodTransform, any>>;
+    transform: z.ZodType<import("./type.js").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type.js").AstryxCodemodTransform, any>>;
     type: z.ZodLiteral<"config">;
 }, z.core.$strict>], "type">;
 export {};

package/authoring/codemod/parse.mjs

@@ -10,12 +10,14 @@
 import {z} from 'zod';
 import {formatZodError} from '../_shared/errors.mjs';
 
-/** @typedef {import('./type').AstryxCodemod} AstryxCodemod */
-/** @typedef {import('./type').AstryxConfigCodemod} AstryxConfigCodemod */
-/** @typedef {import('./type').AstryxCodemodTransform} AstryxCodemodTransform */
+/** @typedef {import('./type.js').AstryxCodemod} AstryxCodemod */
+/** @typedef {import('./type.js').AstryxConfigCodemod} AstryxConfigCodemod */
+/** @typedef {import('./type.js').AstryxCodemodTransform} AstryxCodemodTransform */
 
 const transform = /** @type {z.ZodType<AstryxCodemodTransform>} */ (
-  z.custom(value => typeof value === 'function', {message: 'Expected a function'})
+  z.custom(value => typeof value === 'function', {
+    message: 'Expected a function',
+  })
 );
 
 const codeCodemodSchema = z
@@ -52,8 +54,8 @@ const codemodEnvelopeSchema = z.discriminatedUnion('type', [
  * Compile-time drift-lock: sealed envelope must infer exactly the public
  * stamped-codemod union.
  *
- * @typedef {import('../_shared/contract').Expect<
- *   import('../_shared/contract').Equal<
+ * @typedef {import('../_shared/contract.js').Expect<
+ *   import('../_shared/contract.js').Equal<
  *     z.infer<typeof codemodEnvelopeSchema>,
  *     AstryxCodemod | AstryxConfigCodemod
  *   >

package/authoring/config/parse.d.mts

@@ -6,8 +6,8 @@
  * {@link AstryxConfig} type. If they drift, `Equal` becomes `false` and
  * `Expect<false>` fails the `tsconfig.authoring-contract.json` typecheck.
  *
- * @typedef {import('../_shared/contract').Expect<
- *   import('../_shared/contract').MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>
+ * @typedef {import('../_shared/contract.js').Expect<
+ *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>
  * >} _ConfigDriftLock
  */
 /**
@@ -23,13 +23,13 @@ export function parseConfig(input: unknown, label?: string): AstryxConfig;
  * {@link AstryxConfig} type. If they drift, `Equal` becomes `false` and
  * `Expect<false>` fails the `tsconfig.authoring-contract.json` typecheck.
  */
-export type _ConfigDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>>;
-export type AstryxConfig = import("./type").AstryxConfig;
-export type PostCodemodHook = import("./type").PostCodemodHook;
-export type XleComponent = import("./type").XleComponent;
-export type DebugConfig = import("./type").DebugConfig;
-export type DebugEventHandler = import("../debug/type").DebugEventHandler;
-export type GapReportHandler = import("../gap-report/type").GapReportHandler;
+export type _ConfigDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>>;
+export type AstryxConfig = import("./type.js").AstryxConfig;
+export type PostCodemodHook = import("./type.js").PostCodemodHook;
+export type XleComponent = import("./type.js").XleComponent;
+export type DebugConfig = import("./type.js").DebugConfig;
+export type DebugEventHandler = import("../debug/type.js").DebugEventHandler;
+export type GapReportHandler = import("../gap-report/type.js").GapReportHandler;
 import { z } from 'zod';
 declare const configSchema: z.ZodObject<{
     integrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -40,14 +40,14 @@ declare const configSchema: z.ZodObject<{
             buildCommand: z.ZodType<(ctx: {
                 packageDir: string;
                 files: string[];
-            }) => import("./type").PostCodemodCommand | null | undefined | Promise<import("./type").PostCodemodCommand | null | undefined>, any, z.core.$ZodTypeInternals<(ctx: {
+            }) => import("./type.js").PostCodemodCommand | null | undefined | Promise<import("./type.js").PostCodemodCommand | null | undefined>, any, z.core.$ZodTypeInternals<(ctx: {
                 packageDir: string;
                 files: string[];
-            }) => import("./type").PostCodemodCommand | null | undefined | Promise<import("./type").PostCodemodCommand | null | undefined>, any>>;
+            }) => import("./type.js").PostCodemodCommand | null | undefined | Promise<import("./type.js").PostCodemodCommand | null | undefined>, any>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
-    debug: z.ZodOptional<z.ZodType<import("../debug/type").DebugEventHandler, any, z.core.$ZodTypeInternals<import("../debug/type").DebugEventHandler, any>>>;
-    gapReport: z.ZodOptional<z.ZodType<import("../gap-report/type").GapReportHandler, any, z.core.$ZodTypeInternals<import("../gap-report/type").GapReportHandler, any>>>;
+    debug: z.ZodOptional<z.ZodType<import("../debug/type.js").DebugEventHandler, any, z.core.$ZodTypeInternals<import("../debug/type.js").DebugEventHandler, any>>>;
+    gapReport: z.ZodOptional<z.ZodType<import("../gap-report/type.js").GapReportHandler, any, z.core.$ZodTypeInternals<import("../gap-report/type.js").GapReportHandler, any>>>;
     experimental: z.ZodOptional<z.ZodObject<{
         xle: z.ZodOptional<z.ZodObject<{
             components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/authoring/config/parse.mjs

@@ -13,12 +13,12 @@ import {z} from 'zod';
 import {formatZodError} from '../_shared/errors.mjs';
 import {parseGapReportHandler} from '../gap-report/parse.mjs';
 
-/** @typedef {import('./type').AstryxConfig} AstryxConfig */
-/** @typedef {import('./type').PostCodemodHook} PostCodemodHook */
-/** @typedef {import('./type').XleComponent} XleComponent */
-/** @typedef {import('./type').DebugConfig} DebugConfig */
-/** @typedef {import('../debug/type').DebugEventHandler} DebugEventHandler */
-/** @typedef {import('../gap-report/type').GapReportHandler} GapReportHandler */
+/** @typedef {import('./type.js').AstryxConfig} AstryxConfig */
+/** @typedef {import('./type.js').PostCodemodHook} PostCodemodHook */
+/** @typedef {import('./type.js').XleComponent} XleComponent */
+/** @typedef {import('./type.js').DebugConfig} DebugConfig */
+/** @typedef {import('../debug/type.js').DebugEventHandler} DebugEventHandler */
+/** @typedef {import('../gap-report/type.js').GapReportHandler} GapReportHandler */
 
 // Typed `z.custom` so `z.infer` reproduces the real function type (not `unknown`).
 const buildCommand = /** @type {z.ZodType<PostCodemodHook['buildCommand']>} */ (
@@ -95,8 +95,8 @@ const configSchema = z
  * {@link AstryxConfig} type. If they drift, `Equal` becomes `false` and
  * `Expect<false>` fails the `tsconfig.authoring-contract.json` typecheck.
  *
- * @typedef {import('../_shared/contract').Expect<
- *   import('../_shared/contract').MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>
+ * @typedef {import('../_shared/contract.js').Expect<
+ *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>
  * >} _ConfigDriftLock
  */
 

package/authoring/config/type.ts

@@ -9,8 +9,8 @@
  * boundary; there is no factory to call.
  */
 
-import type {DebugEventHandler} from '../debug/type';
-import type {GapReportHandler} from '../gap-report/type';
+import type {DebugEventHandler} from '../debug/type.js';
+import type {GapReportHandler} from '../gap-report/type.js';
 
 /**
  * A command to run as part of a post-codemod hook. Returned by a hook's
@@ -21,7 +21,7 @@ export interface PostCodemodCommand {
   args?: string[];
   options?: {
     cwd?: string;
-    env?: NodeJS.ProcessEnv;
+    env?: Record<string, string | undefined>;
     timeout?: number;
   };
 }

package/authoring/debug/parse.d.mts

@@ -7,8 +7,8 @@
  * `Expect<false>` fails the `tsconfig.authoring-contract.json` typecheck —
  * so a field added to the recorder without being published here breaks CI.
  *
- * @typedef {import('../_shared/contract').Expect<
- *   import('../_shared/contract').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
+ * @typedef {import('../_shared/contract.js').Expect<
+ *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
  * >} _DebugEventDriftLock
  */
 /**
@@ -29,8 +29,8 @@ export function parseDebugEvent(input: unknown, label?: string): DebugEvent;
  * `Expect<false>` fails the `tsconfig.authoring-contract.json` typecheck —
  * so a field added to the recorder without being published here breaks CI.
  */
-export type _DebugEventDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>>;
-export type DebugEvent = import("./type").DebugEvent;
+export type _DebugEventDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>>;
+export type DebugEvent = import("./type.js").DebugEvent;
 import { z } from 'zod';
 declare const eventSchema: z.ZodObject<{
     schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
@@ -77,12 +77,12 @@ declare const eventSchema: z.ZodObject<{
         resultKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
             theme: "theme";
             component: "component";
+            command: "command";
             hook: "hook";
             doc: "doc";
             template: "template";
             integration: "integration";
             migration: "migration";
-            command: "command";
             mixed: "mixed";
             none: "none";
         }>>>;

package/authoring/debug/parse.mjs

@@ -22,7 +22,7 @@
 import {z} from 'zod';
 import {formatZodError} from '../_shared/errors.mjs';
 
-/** @typedef {import('./type').DebugEvent} DebugEvent */
+/** @typedef {import('./type.js').DebugEvent} DebugEvent */
 
 const outcomeSchema = z.enum([
   'ok',
@@ -169,8 +169,8 @@ const eventSchema = z
  * `Expect<false>` fails the `tsconfig.authoring-contract.json` typecheck —
  * so a field added to the recorder without being published here breaks CI.
  *
- * @typedef {import('../_shared/contract').Expect<
- *   import('../_shared/contract').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
+ * @typedef {import('../_shared/contract.js').Expect<
+ *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
  * >} _DebugEventDriftLock
  */