@absolutejs/absolute 0.20.0-beta.76 → 0.20.0-beta.78

package/dist/src/build/buildDepVendor.d.ts

@@ -1,2 +1,3 @@
+export declare const collectTransitiveImports: (specs: Iterable<string>, alreadyVendored: Set<string>, alreadyScanned: Set<string>) => Promise<Set<string>>;
 export declare const buildDepVendor: (buildDir: string, directories: string[], files?: string[]) => Promise<Record<string, string>>;
 export declare const computeDepVendorPaths: (directories: string[], files?: string[]) => Promise<Record<string, string>>;

package/dist/src/cli/scripts/migrate.d.ts

@@ -0,0 +1,2 @@
+/** Report what a migration would involve, without changing anything. */
+export declare const migrate: (root?: string) => void;

package/dist/src/cli/scripts/workspace.d.ts

@@ -8,5 +8,19 @@ export declare const findSharedWorkspaceBuildDirectories: (services: WorkspaceCo
     buildDirectory: string;
     names: string[];
 }[];
+/** Start every service, and tear down whatever already started if any of them
+ *  never becomes ready.
+ *
+ *  Without this a readiness timeout rejects out of the whole command while the
+ *  children it already spawned keep running. The result is worse than a clean
+ *  failure: an orphaned server still holding the port, with no supervisor and
+ *  no hot reload, which looks like a working server right up until an edit
+ *  never lands or a click hits a stale bundle. Failing to start must leave
+ *  nothing behind. */
+export declare const startWorkspaceOrShutDown: ({ onFailure, shutdown, start }: {
+    onFailure: (message: string) => void;
+    shutdown: (exitCode: number) => Promise<void> | void;
+    start: () => Promise<void>;
+}) => Promise<boolean>;
 export declare const workspace: (subcommand: string | undefined, options: WorkspaceDevOptions) => Promise<void>;
 export {};

package/dist/src/dev/moduleServer.d.ts

@@ -11,6 +11,10 @@ type ModuleServerConfig = {
     };
     stylePreprocessors?: StylePreprocessorConfig;
 };
+/** The named bindings of an import clause, so a stub can export exactly what
+ *  the importer expects. Aliases keep the source name (`{ a as b }` needs `a`
+ *  exported); a namespace or default import needs nothing extra. */
+export declare const importedBindingNames: (clause: string) => string[];
 export declare const isReactFastRefreshSupported: () => boolean;
 export declare const warnIfReactFastRefreshUnsupported: () => void;
 export declare const warmCompilers: (frameworks: {

package/dist/src/migrate/detect.d.ts

@@ -0,0 +1,25 @@
+import type { StackDetection } from './types';
+/** Below this, a caller should ask rather than assume. A single weak signal
+ *  — say a `vite` devDependency in an otherwise unrecognisable repo — is a
+ *  hint, not a verdict. */
+export declare const CONFIDENT = 0.7;
+type Manifest = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+};
+export type DetectionInput = {
+    /** Parsed package.json, or null when the repo has none. */
+    manifest: Manifest | null;
+    /** Repo-relative paths of files at or near the root. Directory entries
+     *  may be included; only names are ever compared. */
+    files: readonly string[];
+};
+/** Identify the framework a project is built on.
+ *
+ *  Returns `unknown` with zero confidence rather than guessing when nothing
+ *  matches — a wrong stack sends a migration down a path that cannot work,
+ *  which is worse than admitting ignorance and asking. */
+export declare const detectStack: ({ manifest, files }: DetectionInput) => StackDetection;
+export {};

package/dist/src/migrate/scan.d.ts

@@ -0,0 +1,14 @@
+import { type CatalogEntryLike, type SubstitutionRule } from './substitutions';
+import type { MigrationPlan } from './types';
+/** Repo-relative paths, skipping build output and vendored code. */
+export declare const listProjectFiles: (root: string, limit?: number) => string[];
+/** Which files import each of `packages`. A plain substring test over the
+ *  quoted specifier: an import map does not need a parser, and being wrong
+ *  here costs a slightly long list, not a bad edit. */
+export declare const findImporters: (root: string, files: readonly string[], packages: readonly string[]) => Record<string, string[]>;
+export type ScanOptions = {
+    catalog?: readonly CatalogEntryLike[];
+    rules?: readonly SubstitutionRule[];
+};
+/** Read a project and produce the plan. Does not modify anything. */
+export declare const scanProject: (root: string, { catalog, rules }?: ScanOptions) => MigrationPlan;

package/dist/src/migrate/substitutions.d.ts

@@ -0,0 +1,37 @@
+export type SubstitutionRule = {
+    /** The third-party dependency, as it appears in package.json. */
+    from: string;
+    /** The first-party package that covers it. */
+    to: string;
+    /** One line a reader can judge without opening documentation. */
+    rationale: string;
+};
+/** Minimum a caller must tell us about the catalog. Deliberately structural
+ *  rather than an import of Studio's generated type: the CLI ships a
+ *  snapshot, Studio passes its live catalog, and neither should have to
+ *  match the other's exact shape. */
+export type CatalogEntryLike = {
+    name: string;
+};
+export declare const DEFAULT_SUBSTITUTION_RULES: readonly SubstitutionRule[];
+export type SubstitutionInput = {
+    /** Dependency names declared by the project, any section. */
+    dependencies: readonly string[];
+    /** Repo-relative files importing each dependency. A dependency absent
+     *  from this map is reported with an empty `usedIn` — declared but never
+     *  imported is still worth knowing, for a different reason. */
+    importsByPackage?: Readonly<Record<string, readonly string[]>>;
+    /** The packages that actually exist. Suggestions are filtered to these. */
+    catalog: readonly CatalogEntryLike[];
+    rules?: readonly SubstitutionRule[];
+};
+/** Find dependencies that have a first-party equivalent.
+ *
+ *  Ordered by how much evidence there is that the dependency is really in
+ *  use, so a caller rendering the top few shows the ones that matter. */
+export declare const planSubstitutions: ({ dependencies, importsByPackage, catalog, rules }: SubstitutionInput) => {
+    from: string;
+    rationale: string;
+    to: string;
+    usedIn: string[];
+}[];

package/dist/src/migrate/types.d.ts

@@ -0,0 +1,40 @@
+/** Frameworks the detector can recognise in a project it did not create. */
+export type StackKind = 'absolutejs' | 'astro' | 'create-react-app' | 'nextjs' | 'nuxt' | 'remix' | 'sveltekit' | 'unknown' | 'vite';
+/** Why the detector reached its conclusion, so a human (or a model) can
+ *  disagree with it on evidence rather than on trust. */
+export type StackEvidence = {
+    /** Repo-relative path the signal came from. */
+    source: string;
+    /** What was found there, in one line. */
+    detail: string;
+};
+export type StackDetection = {
+    kind: StackKind;
+    /** 0-1. Below `CONFIDENT` the caller should ask rather than assume. */
+    confidence: number;
+    evidence: StackEvidence[];
+    /** Every stack that matched at all, strongest first — a Next.js app that
+     *  also uses Vite should not silently lose the second fact. */
+    alternates: StackKind[];
+};
+/** A dependency that has a first-party equivalent. Suggestion only: the
+ *  engine never rewrites imports on its own, because silently swapping
+ *  somebody's auth library is not a refactor, it is a surprise. */
+export type PackageSubstitution = {
+    /** The dependency currently in package.json. */
+    from: string;
+    /** The `@absolutejs/*` package that covers it. */
+    to: string;
+    /** Where `from` is required, repo-relative. Empty when it is declared but
+     *  never imported — still worth reporting, for a different reason. */
+    usedIn: string[];
+    /** One line a human can judge without opening docs. */
+    rationale: string;
+};
+/** How a caller wants edits applied. Mirrors the shape people already know
+ *  from an editor agent: propose and wait, or apply and let them review. */
+export type ApplyMode = 'apply' | 'propose';
+export type MigrationPlan = {
+    detection: StackDetection;
+    substitutions: PackageSubstitution[];
+};

package/package.json

@@ -7,8 +7,8 @@
 		"url": "https://github.com/absolutejs/absolutejs/issues"
 	},
 	"dependencies": {
-		"@absolutejs/auth": "0.75.0",
-		"@absolutejs/beacon": "0.7.0-beta.4",
+		"@absolutejs/auth": ">=0.75.0 <0.77.0",
+		"@absolutejs/beacon": ">=0.7.0-beta.4 <0.8.0",
 		"@absolutejs/devices": "0.7.0",
 		"@absolutejs/devices-capacitor": "0.8.0",
 		"@absolutejs/devices-expo": "0.0.2",
@@ -515,7 +515,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.76",
+	"version": "0.20.0-beta.78",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"