@astryxdesign/cli 0.6.3-canary.c3f0391 → 0.6.3-canary.ccfce9a

package/authoring/_shared/contract.ts

@@ -28,27 +28,5 @@ export type MutuallyAssignable<A, B> = [A] extends [B]
     : false
   : false;
 
-/**
- * `T` without string or number index signatures, at every depth. A
- * `.passthrough()` schema infers one and a hand-written interface never has
- * one, so a lock drops them before comparing named fields. Recursive fields
- * that a schema casts to their public type compare equal by construction.
- */
-export type NamedFields<T> = T extends readonly (infer U)[]
-  ? NamedFields<U>[]
-  : T extends (...args: never[]) => unknown
-    ? T
-    : T extends object
-      ? {
-          [
-            K in keyof T as string extends K
-              ? never
-              : number extends K
-                ? never
-                : K
-          ]: NamedFields<T[K]>;
-        }
-      : T;
-
 /** Compiles only when `T` is exactly `true`; otherwise a type error. */
 export type Expect<T extends true> = T;

package/authoring/codemod/codemod.doc.mjs

@@ -63,13 +63,11 @@ export const doc = {
               name: 'file.path',
               type: 'string',
               description: 'Absolute path to the file being transformed.',
-              required: true,
             },
             {
               name: 'file.source',
               type: 'string',
               description: 'The current source contents of the file.',
-              required: true,
             },
           ],
         },
@@ -83,21 +81,18 @@ export const doc = {
               type: 'unknown',
               description:
                 'A jscodeshift instance configured with a parser for the file.',
-              required: true,
             },
             {
               name: 'api.stats',
               type: '(...args: unknown[]) => void',
               description:
                 'Report a statistic (no-op-friendly; provided for jscodeshift parity).',
-              required: true,
             },
             {
               name: 'api.report',
               type: '(...args: unknown[]) => void',
               description:
                 'Report progress (no-op-friendly; provided for jscodeshift parity).',
-              required: true,
             },
           ],
         },
@@ -105,7 +100,7 @@ export const doc = {
     },
     {
       name: 'type',
-      type: "'code' | 'config'",
+      type: "'code'",
       description:
         "Discriminant for the file-transforming variant. Use 'config' for a " +
         'codemod that rewrites astryx.config.* instead (see notes).',

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.js').Expect<
- *   import('../_shared/contract.js').Equal<
+ * @typedef {import('../_shared/contract').Expect<
+ *   import('../_shared/contract').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.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;
+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;
 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.js").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type.js").AstryxCodemodTransform, any>>;
+    transform: z.ZodType<import("./type").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type").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.js").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type.js").AstryxCodemodTransform, any>>;
+    transform: z.ZodType<import("./type").AstryxCodemodTransform, any, z.core.$ZodTypeInternals<import("./type").AstryxCodemodTransform, any>>;
     type: z.ZodLiteral<"config">;
 }, z.core.$strict>], "type">;
 export {};

package/authoring/codemod/parse.mjs

@@ -10,14 +10,12 @@
 import {z} from 'zod';
 import {formatZodError} from '../_shared/errors.mjs';
 
-/** @typedef {import('./type.js').AstryxCodemod} AstryxCodemod */
-/** @typedef {import('./type.js').AstryxConfigCodemod} AstryxConfigCodemod */
-/** @typedef {import('./type.js').AstryxCodemodTransform} AstryxCodemodTransform */
+/** @typedef {import('./type').AstryxCodemod} AstryxCodemod */
+/** @typedef {import('./type').AstryxConfigCodemod} AstryxConfigCodemod */
+/** @typedef {import('./type').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
@@ -54,8 +52,8 @@ const codemodEnvelopeSchema = z.discriminatedUnion('type', [
  * Compile-time drift-lock: sealed envelope must infer exactly the public
  * stamped-codemod union.
  *
- * @typedef {import('../_shared/contract.js').Expect<
- *   import('../_shared/contract.js').Equal<
+ * @typedef {import('../_shared/contract').Expect<
+ *   import('../_shared/contract').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.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>
+ * @typedef {import('../_shared/contract').Expect<
+ *   import('../_shared/contract').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.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;
+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;
 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.js").PostCodemodCommand | null | undefined | Promise<import("./type.js").PostCodemodCommand | null | undefined>, any, z.core.$ZodTypeInternals<(ctx: {
+            }) => import("./type").PostCodemodCommand | null | undefined | Promise<import("./type").PostCodemodCommand | null | undefined>, any, z.core.$ZodTypeInternals<(ctx: {
                 packageDir: string;
                 files: string[];
-            }) => import("./type.js").PostCodemodCommand | null | undefined | Promise<import("./type.js").PostCodemodCommand | null | undefined>, any>>;
+            }) => import("./type").PostCodemodCommand | null | undefined | Promise<import("./type").PostCodemodCommand | null | undefined>, any>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
-    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>>>;
+    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>>>;
     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.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 */
+/** @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 */
 
 // 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.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof configSchema>, AstryxConfig>
+ * @typedef {import('../_shared/contract').Expect<
+ *   import('../_shared/contract').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.js';
-import type {GapReportHandler} from '../gap-report/type.js';
+import type {DebugEventHandler} from '../debug/type';
+import type {GapReportHandler} from '../gap-report/type';
 
 /**
  * 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?: Record<string, string | undefined>;
+    env?: NodeJS.ProcessEnv;
     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.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
+ * @typedef {import('../_shared/contract').Expect<
+ *   import('../_shared/contract').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.js").Expect<import("../_shared/contract.js").MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>>;
-export type DebugEvent = import("./type.js").DebugEvent;
+export type _DebugEventDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>>;
+export type DebugEvent = import("./type").DebugEvent;
 import { z } from 'zod';
 declare const eventSchema: z.ZodObject<{
     schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;

package/authoring/debug/parse.mjs

@@ -22,7 +22,7 @@
 import {z} from 'zod';
 import {formatZodError} from '../_shared/errors.mjs';
 
-/** @typedef {import('./type.js').DebugEvent} DebugEvent */
+/** @typedef {import('./type').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.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
+ * @typedef {import('../_shared/contract').Expect<
+ *   import('../_shared/contract').MutuallyAssignable<z.infer<typeof eventSchema>, DebugEvent>
  * >} _DebugEventDriftLock
  */
 

package/authoring/doctypes/_schema.d.mts

@@ -91,12 +91,7 @@ export const ReferenceContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         full: "full";
     }>>;
 }, z.core.$strict>], "type">;
-/**
- * New-format stamped component doc (`type: 'component'`): one component's
- * `props`, or the `components` a group doc documents together. These are the
- * shapes the published ComponentDoc type allows, and the ones an unstamped doc
- * may already take.
- */
+/** New-format stamped component doc (`type: 'component'`). */
 export const ComponentDocKindSchema: z.ZodObject<{
     type: z.ZodLiteral<"component">;
     theming: z.ZodOptional<z.ZodUnknown>;
@@ -124,16 +119,13 @@ export const ComponentDocKindSchema: z.ZodObject<{
         public: "public";
         internal: "internal";
     }>>;
-    props: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    props: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         type: z.ZodString;
         description: z.ZodString;
         default: z.ZodOptional<z.ZodString>;
         required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$loose>>>;
-    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-    }, z.core.$loose>>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 /** New-format stamped function doc (`type: 'function'`). */
 export const FunctionDocKindSchema: z.ZodObject<{
@@ -173,26 +165,6 @@ export const FunctionDocKindSchema: z.ZodObject<{
         internal: "internal";
     }>>;
 }, z.core.$loose>;
-/**
- * A stamped function doc as it loads: as with components, `displayName` may be
- * missing and `usage` passes through unchecked.
- *
- * @typedef {Omit<FunctionDoc, 'type' | 'displayName' | 'usage'>
- *   & {type: 'function', displayName?: string, usage?: unknown}} LoadedFunctionDoc
- */
-/**
- * @typedef {import('../_shared/contract.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<
- *     import('../_shared/contract.js').NamedFields<z.infer<typeof FunctionDocKindSchema>>,
- *     import('../_shared/contract.js').NamedFields<LoadedFunctionDoc>
- *   >
- * >} _FunctionDocDriftLock
- */
-/**
- * Every HookDoc is a FunctionDoc, so the one function schema covers both.
- *
- * @typedef {import('../_shared/contract.js').Expect<[HookDoc] extends [FunctionDoc] ? true : false>} _HookDocIsFunctionDocLock
- */
 /**
  * Stamped generic reference/topic doc (`type: 'generic'`). `title` and
  * `sections` stay optional at this parser boundary for docs produced by the
@@ -317,7 +289,7 @@ export const SchemaDocKindSchema: z.ZodObject<{
     description: z.ZodString;
     namespace: z.ZodOptional<z.ZodString>;
     appliesTo: z.ZodOptional<z.ZodString>;
-    fields: z.ZodArray<z.ZodType<import("./schema/type.js").SchemaFieldDoc, any, z.core.$ZodTypeInternals<import("./schema/type.js").SchemaFieldDoc, any>>>;
+    fields: z.ZodArray<z.ZodType<import("./schema/type").SchemaFieldDoc, any, z.core.$ZodTypeInternals<import("./schema/type").SchemaFieldDoc, any>>>;
     examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodOptional<z.ZodString>;
         code: z.ZodString;
@@ -398,14 +370,6 @@ export const SchemaDocKindSchema: z.ZodObject<{
         internal: "internal";
     }>>;
 }, z.core.$loose>;
-/**
- * @typedef {import('../_shared/contract.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<
- *     import('../_shared/contract.js').NamedFields<z.infer<typeof SchemaDocKindSchema>>,
- *     import('../_shared/contract.js').NamedFields<SchemaDoc & {type: 'schema'}>
- *   >
- * >} _SchemaDocDriftLock
- */
 /** New stamped command doc (`type: 'command'`). */
 export const CommandDocKindSchema: z.ZodObject<{
     type: z.ZodLiteral<"command">;
@@ -517,14 +481,6 @@ export const CommandDocKindSchema: z.ZodObject<{
         internal: "internal";
     }>>;
 }, z.core.$loose>;
-/**
- * @typedef {import('../_shared/contract.js').Expect<
- *   import('../_shared/contract.js').MutuallyAssignable<
- *     import('../_shared/contract.js').NamedFields<z.infer<typeof CommandDocKindSchema>>,
- *     import('../_shared/contract.js').NamedFields<CommandDoc & {type: 'command'}>
- *   >
- * >} _CommandDocDriftLock
- */
 /** New stamped enum doc (`type: 'enum'`). */
 export const EnumDocKindSchema: z.ZodObject<{
     type: z.ZodLiteral<"enum">;
@@ -929,79 +885,13 @@ export const LegacyDocSchema: z.ZodUnion<readonly [z.ZodObject<{
     extends: z.ZodOptional<z.ZodString>;
     tokenCategory: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>]>;
-export type AuthoredDocGraphFieldsType = import("./base/type.js").AuthoredDocGraphFields;
-export type AuthoredDocKind = import("./base/type.js").AuthoredDocKind;
-export type NamespaceDoc = import("./namespace/type.js").NamespaceDoc;
-export type ReferenceContentBlock = import("./reference/type.js").ReferenceContentBlock;
-export type ReferenceDoc = import("./reference/type.js").ReferenceDoc;
-export type SingleComponentDoc = import("./component/type.js").SingleComponentDoc;
-export type ComponentPropDoc = import("./base/type.js").ComponentPropDoc;
-export type HookDoc = import("./hook/type.js").HookDoc;
-export type FunctionDoc = import("./function/type.js").FunctionDoc;
-export type SchemaDoc = import("./schema/type.js").SchemaDoc;
-export type CommandDoc = import("./command/type.js").CommandDoc;
-export type EnumDoc = import("./enum/type.js").EnumDoc;
-export type _AuthoredDocKindDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof AuthoredDocKindSchema>, AuthoredDocKind>>;
-export type _AuthoredDocGraphDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<z.infer<typeof _AuthoredDocGraphSchema>, AuthoredDocGraphFieldsType>>;
-export type _ReferenceContentBlockDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof ReferenceContentBlockSchema>, ReferenceContentBlock>>;
-/**
- * A stamped component doc as it loads. The loader accepts what the unstamped
- * format always accepted, so stamping an existing doc never breaks it:
- * `displayName` may be missing, `category` is any string, `usage`, `theming`,
- * `playground` and `examples` pass through unchecked, and a doc has `props`,
- * `components`, or both; each `components` entry needs only a `name`. Every
- * other field matches the published type.
- */
-export type LoadedComponentDoc = Omit<SingleComponentDoc, "type" | "displayName" | "category" | "usage" | "theming" | "examples" | "playground" | "props"> & {
-    type: "component";
-    displayName?: string;
-    category?: string;
-    usage?: unknown;
-    theming?: unknown;
-    examples?: unknown[];
-    playground?: unknown;
-    props?: ComponentPropDoc[];
-    components?: Array<{
-        name: string;
-    }>;
-};
-export type _ComponentDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<import("../_shared/contract.js").NamedFields<z.infer<typeof ComponentDocKindSchema>>, import("../_shared/contract.js").NamedFields<LoadedComponentDoc>>>;
-/**
- * A stamped function doc as it loads: as with components, `displayName` may be
- * missing and `usage` passes through unchecked.
- */
-export type LoadedFunctionDoc = Omit<FunctionDoc, "type" | "displayName" | "usage"> & {
-    type: "function";
-    displayName?: string;
-    usage?: unknown;
-};
-export type _FunctionDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<import("../_shared/contract.js").NamedFields<z.infer<typeof FunctionDocKindSchema>>, import("../_shared/contract.js").NamedFields<LoadedFunctionDoc>>>;
-/**
- * Every HookDoc is a FunctionDoc, so the one function schema covers both.
- */
-export type _HookDocIsFunctionDocLock = import("../_shared/contract.js").Expect<[HookDoc] extends [FunctionDoc] ? true : false>;
-/**
- * A stamped generic doc as the load check accepts it. `title`, `description`
- * and `sections` may be missing, as in docs the v0.3.0 factory-removal codemod
- * produced; `parseReference` then fills them (title from `displayName` or
- * `name`, an empty description, no sections), so its result is a full
- * ReferenceDoc. Only a doc with a description and sections is a usable topic
- * (see `problemsInTopic`).
- */
-export type LoadedReferenceDoc = Omit<ReferenceDoc, "type" | "title" | "description" | "sections"> & {
-    type: "generic";
-} & Partial<Pick<ReferenceDoc, "title" | "description" | "sections">>;
-export type _ReferenceDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<import("../_shared/contract.js").NamedFields<z.infer<typeof GenericDocKindSchema>>, import("../_shared/contract.js").NamedFields<LoadedReferenceDoc>>>;
-export type _SchemaDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<import("../_shared/contract.js").NamedFields<z.infer<typeof SchemaDocKindSchema>>, import("../_shared/contract.js").NamedFields<SchemaDoc & {
-    type: "schema";
-}>>>;
-export type _CommandDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<import("../_shared/contract.js").NamedFields<z.infer<typeof CommandDocKindSchema>>, import("../_shared/contract.js").NamedFields<CommandDoc & {
-    type: "command";
-}>>>;
-export type _EnumDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<import("../_shared/contract.js").NamedFields<z.infer<typeof EnumDocKindSchema>>, import("../_shared/contract.js").NamedFields<EnumDoc & {
-    type: "enum";
-}>>>;
-export type _NamespaceDocDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof NamespaceDocKindSchema>, NamespaceDoc>>;
+export type AuthoredDocGraphFieldsType = import("./base/type").AuthoredDocGraphFields;
+export type AuthoredDocKind = import("./base/type").AuthoredDocKind;
+export type NamespaceDoc = import("./namespace/type").NamespaceDoc;
+export type ReferenceContentBlock = import("./reference/type").ReferenceContentBlock;
+export type _AuthoredDocGraphDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").MutuallyAssignable<z.infer<typeof _AuthoredDocGraphSchema>, AuthoredDocGraphFieldsType>>;
+export type _ReferenceContentBlockDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").Equal<z.infer<typeof ReferenceContentBlockSchema>, ReferenceContentBlock>>;
+export type _NamespaceDocDriftLock = import("../_shared/contract").Expect<import("../_shared/contract").Equal<z.infer<typeof NamespaceDocKindSchema>, NamespaceDoc>>;
 import { z } from 'zod';
 declare const _AuthoredDocGraphSchema: z.ZodObject<{
     placement: z.ZodOptional<z.ZodObject<{