@lucent-lang/lucent 0.0.4 → 0.1.0

package/dist/{codes-CIuwXt1S.js → codes-D-6LxUqD.js}

@@ -9,6 +9,7 @@ const Codes = {
 	UnsupportedCall: "LUCENT1007",
 	UnsupportedAssignmentTarget: "LUCENT1008",
 	UnsupportedLoop: "LUCENT1009",
+	AwaitNative: "LUCENT1010",
 	AnyType: "LUCENT2001",
 	UnsupportedType: "LUCENT2002",
 	InexactObject: "LUCENT2003",
@@ -25,9 +26,38 @@ const Codes = {
 	PlatformConformance: "LUCENT3005",
 	MainThreadOnly: "LUCENT3006",
 	Unavailable: "LUCENT3007",
+	ConstantOutsideGroup: "LUCENT3008",
+	BlockingOnMain: "LUCENT3009",
+	ModuleNameClash: "LUCENT3010",
+	NotIsolated: "LUCENT3011",
+	NotTransferable: "LUCENT3012",
+	ComponentExport: "LUCENT3020",
+	ComponentContract: "LUCENT3021",
+	ComponentMainThread: "LUCENT3022",
+	ComponentPlatforms: "LUCENT3023",
+	ToolkitBody: "LUCENT3024",
+	BorrowEscape: "LUCENT3030",
+	UseAfterMove: "LUCENT3031",
 	TypeScript: "LUCENT9001"
 };
 const ex = (source, name = "example.lucent.ts") => ({ [name]: source });
+const component = (source, name = "title") => ({
+	"package.json": "{ \"name\": \"example-app\" }\n",
+	[`${name}.lucent.tsx`]: source
+});
+const LABEL_IMPORTS = "import { PLATFORM } from \"lucent:platform\";\nimport { appContext } from \"lucent:android\";\nimport { TextView } from \"lucent:android/android.widget\";\nimport { UILabel } from \"lucent:ios/UIKit\";\n";
+const LABEL_BODY = "  if (PLATFORM === \"ios\") {\n    const label = new UILabel();\n    label.text = props.title;\n    return label;\n  }\n  const text = new TextView(appContext());\n  text.setText(props.title);\n  return text;\n}\n";
+const splitTitle = (implProps) => ({
+	"package.json": "{ \"name\": \"example-app\" }\n",
+	"title.lucent.tsx": "import type { TextView } from \"lucent:android/android.widget\";\nimport type { UILabel } from \"lucent:ios/UIKit\";\nexport declare function Title(props: { title: string; lines: number }): UILabel | TextView;\n",
+	"title.ios.lucent.tsx": `import { UILabel } from "lucent:ios/UIKit";\nexport function Title(props: ${implProps}): UILabel {\n  const label = new UILabel();\n  label.text = props.title;\n  return label;\n}\n`,
+	"title.android.lucent.tsx": `import { appContext } from "lucent:android";\nimport { TextView } from "lucent:android/android.widget";\nexport function Title(props: ${implProps}): TextView {\n  const text = new TextView(appContext());\n  text.setText(props.title);\n  return text;\n}\n`
+});
+const TOOLKIT_TITLE = {
+	"package.json": "{ \"name\": \"example-app\" }\n",
+	"title.lucent.tsx": "import type { TextView } from \"lucent:android/android.widget\";\nimport type { View } from \"lucent:swiftui\";\nexport declare function Title(props: { title: string }): View | TextView;\n",
+	"title.android.lucent.tsx": "import { appContext } from \"lucent:android\";\nimport { TextView } from \"lucent:android/android.widget\";\nimport { effect } from \"lucent:ui\";\nexport function Title(props: { title: string }): TextView {\n  const text = new TextView(appContext());\n  effect(() => text.setText(props.title));\n  return text;\n}\n"
+};
 const Explanations = {
 	LUCENT1001: {
 		title: "Syntax outside the subset",
@@ -39,8 +69,8 @@ const Explanations = {
 	},
 	LUCENT1002: {
 		title: "Unsupported operator",
-		summary: "An operator used outside what the subset supports, such as `delete`, `in` on anything but a record, or `instanceof` with a generic class.",
-		details: "Objects in Lucent have a fixed native layout, so an operator that adds or removes properties at run time (`delete`) has no native equivalent. `in` works on records (`Record<string, T>`), whose keys are dynamic, and not on objects with a known shape.",
+		summary: "An operator the subset doesn't support, such as `delete`, `in` on anything but a record, or `instanceof` with a generic class. A loose `==` that JavaScript converts for, or comparing two functions, is refused too.",
+		details: "Objects in Lucent have a fixed native layout, so an operator that adds or removes properties at run time (`delete`) has no native equivalent. `in` works on records (`Record<string, T>`), whose keys are dynamic, and not on objects with a known shape. Two functions cannot be compared, because a function value has no stable identity (a named function is a new value at each use).",
 		fix: "use a Map or a Record for keys that come and go, or an optional field for one that may be missing",
 		wrong: ex("export function clear(tags: { name?: string }): { name?: string } {\n  delete tags.name;\n  return tags;\n}\n"),
 		right: ex("export function clear(tags: { name?: string }): { name?: string } {\n  tags.name = undefined;\n  return tags;\n}\n")
@@ -101,6 +131,15 @@ const Explanations = {
 		wrong: ex("export async function total(xs: Promise<number>[]): Promise<number> {\n  let sum = 0;\n  for await (const x of xs) sum += x;\n  return sum;\n}\n"),
 		right: ex("export async function total(xs: Promise<number>[]): Promise<number> {\n  let sum = 0;\n  for (const x of xs) sum += await x;\n  return sum;\n}\n")
 	},
+	LUCENT1010: {
+		title: "Await on a native object",
+		summary: "`await` on a platform SDK object, such as a Play services Task or a Java future: it is not a promise.",
+		details: "A native object reports its completion through its own API, usually a listener, so awaiting it would give the object back at once. Lucent does not recognize libraries by class name, so it cannot pick that API for you. `fromCallback` from `lucent:core` turns the listener into a promise: register it, then call `resolve` or `reject` from it.",
+		fix: "wrap the listener or callback that reports its completion in fromCallback (lucent:core), and await that",
+		wrong: ex("import { PLATFORM } from \"lucent:platform\";\nimport { CompletableFuture } from \"lucent:android/java.util.concurrent\";\nexport async function ready(): Promise<boolean> {\n  if (PLATFORM !== \"android\") return true;\n  const value = await CompletableFuture.completedFuture(\"ready\");\n  return value !== null;\n}\n"),
+		right: ex("import { fromCallback } from \"lucent:core\";\nimport { PLATFORM } from \"lucent:platform\";\nimport type { Throwable } from \"lucent:android/java.lang\";\nimport { CompletableFuture } from \"lucent:android/java.util.concurrent\";\nexport async function ready(): Promise<boolean> {\n  if (PLATFORM !== \"android\") return true;\n  const future = CompletableFuture.completedFuture(\"ready\");\n  const value = await fromCallback<string | null>((resolve, reject) => {\n    future?.whenComplete((v: string | null, failure: Throwable | null) => {\n      if (failure) reject(new Error(failure.getMessage() ?? \"failed\"));\n      else resolve(v);\n    });\n  });\n  return value !== null;\n}\n"),
+		sdk: "android"
+	},
 	LUCENT2001: {
 		title: "Value without a native type",
 		summary: "`any`, or `unknown` outside a `catch` clause: every value needs a native type.",
@@ -111,8 +150,8 @@ const Explanations = {
 	},
 	LUCENT2002: {
 		title: "Type without a native representation",
-		summary: "A type with no native representation: intersections, `bigint`, `symbol`, `object`, `WeakMap`, `Intl`, or an index signature mixed with properties.",
-		details: "Each type maps to one native representation. An intersection can combine unrelated layouts, `bigint` and `symbol` are not implemented yet, and `object` says nothing about the layout.",
+		summary: "A type with no native representation: intersections, `symbol`, `object`, `WeakMap`, `Intl`, or an index signature mixed with properties.",
+		details: "Each type maps to one native representation. An intersection can combine unrelated layouts, `symbol` is not implemented yet, and `object` says nothing about the layout.",
 		fix: "spell the combined type out as one object type, or use a concrete type",
 		wrong: ex("type Named = { name: string };\ntype Aged = { age: number };\nexport function label(p: Named & Aged): string {\n  return `${p.name} (${p.age})`;\n}\n"),
 		right: ex("type Person = { name: string; age: number };\nexport function label(p: Person): string {\n  return `${p.name} (${p.age})`;\n}\n")
@@ -239,11 +278,128 @@ const Explanations = {
 		title: "Platform API newer than the oldest supported OS",
 		summary: "A platform API newer than the oldest supported OS version, used without an `available()` or `SDK_INT` check around it.",
 		details: "Apps run on older OS versions than the SDK they build with. An API introduced later crashes there, so Lucent requires a check that the running OS has it.",
-		fix: "check first: if (available(\"android\", 26)) … or Build_VERSION.SDK_INT >= 26",
-		wrong: ex("import { PLATFORM } from \"lucent:platform\";\nimport { VibrationEffect } from \"lucent:android/android.os\";\nexport async function effect(): Promise<string> {\n  if (PLATFORM === \"android\") {\n    VibrationEffect.createOneShot(10, 10);\n    return \"made\";\n  }\n  return \"none\";\n}\n"),
-		right: ex("import { PLATFORM } from \"lucent:platform\";\nimport { available } from \"lucent:android\";\nimport { VibrationEffect } from \"lucent:android/android.os\";\nexport async function effect(): Promise<string> {\n  if (PLATFORM === \"android\") {\n    if (!available(\"android\", 26)) return \"too old\";\n    VibrationEffect.createOneShot(10, 10);\n    return \"made\";\n  }\n  return \"none\";\n}\n"),
+		fix: "check first: if (available(\"ios\", 16)) …, if (available(\"android\", 26)) … or Build_VERSION.SDK_INT >= 26",
+		wrong: ex("import { PLATFORM } from \"lucent:platform\";\nimport { VibrationEffect } from \"lucent:android/android.os\";\nexport async function effect(): Promise<string> {\n  if (PLATFORM === \"android\") {\n    VibrationEffect.createOneShot(10n, 10);\n    return \"made\";\n  }\n  return \"none\";\n}\n"),
+		right: ex("import { PLATFORM } from \"lucent:platform\";\nimport { available } from \"lucent:android\";\nimport { VibrationEffect } from \"lucent:android/android.os\";\nexport async function effect(): Promise<string> {\n  if (PLATFORM === \"android\") {\n    if (!available(\"android\", 26)) return \"too old\";\n    VibrationEffect.createOneShot(10n, 10);\n    return \"made\";\n  }\n  return \"none\";\n}\n"),
 		sdk: "android"
 	},
+	LUCENT3008: {
+		title: "Constant outside its group",
+		summary: "An Android SDK argument that is a constant outside the @IntDef or @StringDef group the SDK allows there.",
+		details: "The SDK says which constants a parameter takes (@IntDef, @StringDef). A literal or constant outside that group compiles, as in Java, but the platform rejects or misreads it; Lucent warns, as Android lint does.",
+		fix: "pass one of the constants the warning lists",
+		severity: "warning",
+		wrong: ex("import { PLATFORM } from \"lucent:platform\";\nimport { Toast } from \"lucent:android/android.widget\";\nimport { appContext } from \"lucent:android\";\nexport async function toast(): Promise<boolean> {\n  if (PLATFORM === \"android\") return Toast.makeText(appContext(), \"hi\", 5) !== null;\n  return false;\n}\n"),
+		right: ex("import { PLATFORM } from \"lucent:platform\";\nimport { Toast } from \"lucent:android/android.widget\";\nimport { appContext } from \"lucent:android\";\nexport async function toast(): Promise<boolean> {\n  if (PLATFORM === \"android\")\n    return Toast.makeText(appContext(), \"hi\", Toast.LENGTH_SHORT) !== null;\n  return false;\n}\n"),
+		sdk: "android"
+	},
+	LUCENT3009: {
+		title: "Blocking call on the main thread",
+		summary: "An Android SDK member marked @WorkerThread, called inside main(() => …) or a main-thread callback.",
+		details: "@WorkerThread members do blocking work (disk, network, IPC). On the main thread they freeze the UI and can trigger an \"application not responding\" dialog. The call compiles, but Lucent warns, as Android lint does.",
+		fix: "call it outside main(() => …): async Lucent functions run on the Lucent thread",
+		severity: "warning",
+		wrong: ex("import { PLATFORM } from \"lucent:platform\";\nimport { BlockedNumberContract } from \"lucent:android/android.provider\";\nimport { appContext } from \"lucent:android\";\nimport { main } from \"lucent:thread\";\nexport async function blocked(n: string): Promise<boolean> {\n  if (PLATFORM === \"android\") return main(() => BlockedNumberContract.isBlocked(appContext(), n));\n  return false;\n}\n"),
+		right: ex("import { PLATFORM } from \"lucent:platform\";\nimport { BlockedNumberContract } from \"lucent:android/android.provider\";\nimport { appContext } from \"lucent:android\";\nexport async function blocked(n: string): Promise<boolean> {\n  if (PLATFORM === \"android\") return BlockedNumberContract.isBlocked(appContext(), n);\n  return false;\n}\n")
+	},
+	LUCENT3010: {
+		title: "Two modules with one name",
+		summary: "Two Lucent modules in one app whose files give them the same module name.",
+		details: "A module's name is its file name without the directory, the platform suffix and `.lucent.ts` (inside a Lucent package, its path under the package's sources). The app's native side registers each module under that name, so two files that share it would be one module.",
+		fix: "rename one of the files",
+		wrong: {
+			"screens/clock.lucent.ts": "export function now(): number {\n  return Date.now();\n}\n",
+			"sdk/clock.lucent.ts": "export function zone(): string {\n  return \"UTC\";\n}\n"
+		},
+		right: {
+			"screens/clock.lucent.ts": "export function now(): number {\n  return Date.now();\n}\n",
+			"sdk/zones.lucent.ts": "export function zone(): string {\n  return \"UTC\";\n}\n"
+		}
+	},
+	LUCENT3011: {
+		title: "Code that cannot run in a compute task",
+		summary: "A compute() task touches module state or a computed constant, native code unfit for workers, code the compiler cannot follow, or asynchronous work.",
+		details: "A compute task runs on a worker thread while module code keeps running, so it may only touch its input and what it makes. Module state, non-literal constants (a reload assigns them again), main-thread native code, function values the compiler cannot follow, `await` and timers break that rule. The message gives the path, through every call, to what breaks it.",
+		fix: "pass what the task needs as its input, and apply its result where you await it",
+		wrong: ex("import { compute } from \"lucent:core\";\nconst weights: number[] = [1, 2, 3];\nfunction score(x: number): number {\n  return x * (weights[0] ?? 1);\n}\nexport async function run(x: number): Promise<number> {\n  return await compute(score, x);\n}\n"),
+		right: ex("import { compute } from \"lucent:core\";\nconst weights: number[] = [1, 2, 3];\nfunction score(job: { x: number; weights: number[] }): number {\n  return job.x * (job.weights[0] ?? 1);\n}\nexport async function run(x: number): Promise<number> {\n  return await compute(score, { x, weights });\n}\n")
+	},
+	LUCENT3012: {
+		title: "Value that cannot cross to a compute task",
+		summary: "A compute() task's input or result holds something other than data, such as a function, a promise or a main-thread native object.",
+		details: "A compute task's input is copied at submission, and its result comes back to the caller. Both must be numbers, strings, booleans, arrays, tuples, records, maps, sets, byte arrays, dates, or objects made of those. Functions, promises, main-thread native objects and values of unknown or generic type cannot cross, and the message names which part.",
+		fix: "pass the data the task needs, and keep functions, signals and native objects on the calling side",
+		wrong: ex("import { compute } from \"lucent:core\";\ntype Job = { values: number[]; report: (n: number) => void };\nfunction total(job: Job): number {\n  return job.values.reduce((a, b) => a + b, 0);\n}\nexport async function run(values: number[]): Promise<number> {\n  return await compute(total, { values, report: () => {} });\n}\n"),
+		right: ex("import { compute } from \"lucent:core\";\nfunction total(values: number[]): number {\n  return values.reduce((a, b) => a + b, 0);\n}\nexport async function run(values: number[]): Promise<number> {\n  return await compute(total, values);\n}\n")
+	},
+	LUCENT3020: {
+		title: "Export that cannot be a component",
+		summary: "An exported `.lucent.tsx` function that returns a view but cannot be a component, or Lucent code calling a component.",
+		details: "An exported `.lucent.tsx` function that returns a platform view (a `UIView`, an Android `View`, or a subclass) is a component. React mounts it through a native host, and Lucent identifies it by its package's name, module path and export name. So it returns its view on every path and synchronously, takes one props object or none, and has no type parameters.",
+		fix: "return the view on every path, from one props object, and move other work into a separate function",
+		wrong: component(`${LABEL_IMPORTS}export function Title(props: { title: string; shown: boolean }) {\n  if (!props.shown) return undefined;\n${LABEL_BODY}`),
+		right: component(`${LABEL_IMPORTS}export function Title(props: { title: string }) {\n${LABEL_BODY}`),
+		sdk: "ios"
+	},
+	LUCENT3021: {
+		title: "Component prop, event or command that cannot cross",
+		summary: "A component prop, event or ref command whose type views cannot carry, or whose name React or the host keeps.",
+		details: "Props, event arguments and command arguments and results are plain data: numbers, strings, booleans, string literal unions, arrays and plain objects, possibly null. A function prop is an event named `on…`, whose call from the view posts its arguments to JavaScript, so it returns nothing. `key`, `ref`, `children` and `style` belong to React and the host.",
+		fix: "pass plain data, make events return nothing, and name them onSomething",
+		wrong: component(`${LABEL_IMPORTS}export function Title(props: { title: string; onMeasure?: (width: number) => number }) {\n${LABEL_BODY}`),
+		right: component(`${LABEL_IMPORTS}export function Title(props: { title: string; onMeasure?: (width: number) => void }) {\n${LABEL_BODY}`),
+		sdk: "ios"
+	},
+	LUCENT3022: {
+		title: "Component code that cannot run on the main thread",
+		summary: "A component's setup, or a function it creates, using module state, code the compiler cannot follow, or native code unfit for the main thread.",
+		details: "A component sets up its view on the main (UI) thread, where the handlers it gives the view run too. Module variables belong to the module's thread, code the compiler cannot follow may do anything, and blocking or background-only native code freezes the UI. Calling an event prop directly (`props.onChange?.(value)`) is fine: it posts the event to JavaScript.",
+		fix: "keep the state in the component (a local), or pass it in as a prop",
+		wrong: component(`${LABEL_IMPORTS}let shown = 0;\nexport function Title(props: { title: string }) {\n  shown++;\n${LABEL_BODY}`),
+		right: component(`${LABEL_IMPORTS}export function Title(props: { title: string }) {\n${LABEL_BODY}`),
+		sdk: "ios"
+	},
+	LUCENT3023: {
+		title: "Component that differs between platforms",
+		summary: "A component whose props, events or commands differ between platforms or from its declaration, or that is a component on one platform only.",
+		details: "React sees one component on every platform, so its props, events and commands are the same in every platform's implementation. A split module's shared declaration states the same contract, and the component returns a view on every platform.",
+		fix: "give every platform's implementation the declared props",
+		wrong: splitTitle("{ title: string }"),
+		right: splitTitle("{ title: string; lines: number }"),
+		sdk: "ios"
+	},
+	LUCENT3024: {
+		title: "SwiftUI or Compose body that cannot be compiled",
+		summary: "A component's SwiftUI or Jetpack Compose body that Lucent cannot write out in Swift or Kotlin, or toolkit code used outside such a body.",
+		details: "A component can draw with its platform's toolkit, SwiftUI or Jetpack Compose (internal, under LUCENT_VIEWS=fabric). Lucent writes that body out as Swift or Kotlin, showing the numbers, booleans and strings its setup computes. Toolkit views exist only in a body, whose callbacks call the setup's functions: it doesn't change the setup's state or send events.",
+		fix: "make the view in the body, and move logic into a function of the setup that the body calls",
+		wrong: {
+			...TOOLKIT_TITLE,
+			"title.ios.lucent.tsx": "import { Text } from \"lucent:swiftui\";\nimport { signal } from \"lucent:ui\";\nexport function Title(props: { title: string }) {\n  const taps = signal(0);\n  return <Text onTapGesture={() => taps.set(taps.peek() + 1)}>{props.title}</Text>;\n}\n"
+		},
+		right: {
+			...TOOLKIT_TITLE,
+			"title.ios.lucent.tsx": "import { Text } from \"lucent:swiftui\";\nimport { signal } from \"lucent:ui\";\nexport function Title(props: { title: string }) {\n  const taps = signal(0);\n  const tap = () => {\n    taps.set(taps.peek() + 1);\n  };\n  return <Text onTapGesture={() => tap()}>{props.title}</Text>;\n}\n"
+		},
+		sdk: "ios",
+		views: true
+	},
+	LUCENT3030: {
+		title: "Borrowed bytes that outlive their borrow",
+		summary: "A span that withRead or withWrite lends escapes its callback: returned, stored, kept by a closure or callee, or held across await.",
+		details: "withRead and withWrite lend a buffer's bytes for one synchronous call, and refuse conflicting use only while it runs. After it, a task may write, release or move the bytes, so the message shows how the span would outlive the call. Copy what you need inside the callback, or snapshot the buffer with toUint8Array().",
+		fix: "copy what you need out of the span inside the callback, and return that",
+		wrong: ex("import { NativeBuffer } from \"lucent:core\";\nexport function first(buffer: NativeBuffer): number {\n  const bytes = buffer.withRead((lent) => lent);\n  return bytes[0] ?? 0;\n}\n"),
+		right: ex("import { NativeBuffer } from \"lucent:core\";\nexport function first(buffer: NativeBuffer): number {\n  return buffer.withRead((bytes) => bytes[0] ?? 0);\n}\n")
+	},
+	LUCENT3031: {
+		title: "Native buffer used after it moved",
+		summary: "A NativeBuffer is used after transfer() or after it was handed to compute(), which move its bytes to another buffer.",
+		details: "Moving a buffer hands its bytes, uncopied, to a new owner: the buffer that transfer returns, or a compute task. The old buffer then throws an InvalidStateError on every use, and where the move certainly came first, the compiler reports the use. Use the buffer the move gave you, or copy the bytes before moving them.",
+		fix: "use the buffer transfer() returned, or what the task gives back",
+		wrong: ex("import { NativeBuffer } from \"lucent:core\";\nexport function size(): number {\n  const buffer = NativeBuffer.allocate(8);\n  const moved = buffer.transfer();\n  return buffer.byteLength + moved.byteLength;\n}\n"),
+		right: ex("import { NativeBuffer } from \"lucent:core\";\nexport function size(): number {\n  const buffer = NativeBuffer.allocate(8);\n  const moved = buffer.transfer();\n  return moved.byteLength;\n}\n")
+	},
 	LUCENT9001: {
 		title: "TypeScript error",
 		summary: "A TypeScript error. Lucent stops at type errors, because it compiles from the checker's types.",

package/dist/compiler.js

@@ -1,4 +1,4 @@
-import { n as Explanations, r as docsUrl, t as Codes } from "./codes-CIuwXt1S.js";
-import { A as formatDiagnostic, C as extractionCount, D as sdkModule, E as sdkAvailable, O as sdkModules, S as cachedModules, T as prefetch, _ as usesPlatforms, a as inputsKey, b as coverage, c as withGradleDependencies, d as coreJsPath, f as coreTypesPath, g as projectFiles, h as platformOf, i as report, k as sdkNames, l as writeNativePackage, m as moduleNameOf, n as compile, o as isUpToDate, p as findLucentFiles, r as compileDirectory, s as runtimeDir, t as checkSources, u as LUCENT_EXTENSION, v as moduleNamespace, w as forgetLoadedSdks, x as podsSearchPaths, y as sdkDts } from "./src-BD7f1_aZ.js";
-import { a as satisfies, i as nativeDependencies, n as lucentPackages, r as lucentVersion } from "./packages-HyskKIsY.js";
-export { Codes, Explanations, LUCENT_EXTENSION, cachedModules, checkSources, compile, compileDirectory, coreJsPath, coreTypesPath, docsUrl, extractionCount, findLucentFiles, forgetLoadedSdks, formatDiagnostic, inputsKey, isUpToDate, lucentPackages, lucentVersion, moduleNameOf, moduleNamespace, nativeDependencies, platformOf, podsSearchPaths, prefetch as prefetchSdk, projectFiles, report, runtimeDir, satisfies, sdkAvailable, coverage as sdkCoverage, sdkDts, sdkModule, sdkModules, sdkNames, usesPlatforms, withGradleDependencies, writeNativePackage };
+import { n as Explanations, r as docsUrl, t as Codes } from "./codes-D-6LxUqD.js";
+import { A as findLucentFiles, C as bindExtensions, D as LUCENT_EXTENSION, E as identityScript, F as moduleNamespace, G as cachedModules, I as extensionDts, J as forgetLoadedSdks, L as sdkDts, M as platformOf, N as projectFiles, O as coreJsPath, P as usesPlatforms, Q as sdkNames, R as coverage, S as inNativePackage, T as RUNTIME_ABI, W as podsSearchPaths, X as sdkAvailable, Y as prefetch, _ as VIEW_CONTRACT_VERSION, a as report, b as PACKAGE_FIELDS, c as sdkModules, d as isUpToDate, f as runtimeDir, g as libraryBuildGradle, h as toolkitsFrom, i as projectExtensions, j as moduleNameOf, k as coreTypesPath, l as deferredLibraryGradle, m as jsxToolkits, n as compile, o as sdkDeclarations, p as writeNativePackage, q as extractionCount, r as compileDirectory, s as sdkModule, t as checkSources, tt as formatDiagnostic, u as inputsKey, v as resolveNative, w as forgetExtensionHeaders, x as fileHashes, y as EXTENSION_FIELDS } from "./src-DlICbK91.js";
+import { i as satisfies, n as lucentPackages, r as lucentVersion } from "./packages-CSmKeaAh.js";
+export { Codes, EXTENSION_FIELDS, Explanations, LUCENT_EXTENSION, PACKAGE_FIELDS, RUNTIME_ABI, VIEW_CONTRACT_VERSION, bindExtensions, cachedModules, checkSources, compile, compileDirectory, coreJsPath, coreTypesPath, deferredLibraryGradle, docsUrl, extensionDts, extractionCount, fileHashes, findLucentFiles, forgetExtensionHeaders, forgetLoadedSdks, formatDiagnostic, identityScript, inNativePackage, inputsKey, isUpToDate, jsxToolkits, libraryBuildGradle, lucentPackages, lucentVersion, moduleNameOf, moduleNamespace, platformOf, podsSearchPaths, prefetch as prefetchSdk, projectExtensions, projectFiles, report, resolveNative, runtimeDir, satisfies, sdkAvailable, coverage as sdkCoverage, sdkDeclarations, sdkDts, sdkModule, sdkModules, sdkNames, toolkitsFrom, usesPlatforms, writeNativePackage };

package/dist/{dashboard-B-NzjjaN.js → dashboard-C8iF5-6T.js}

@@ -1,5 +1,5 @@
 import { i as table, n as duration, t as codeFrame } from "./format-D9fnIMEx.js";
-import { n as nextText } from "./pipeline-CH7-2cxu.js";
+import { i as ACTION_TEXT, n as nextText } from "./pipeline-BBY0df_2.js";
 import { Box, Text, render, useApp, useInput } from "ink";
 import { useState, useSyncExternalStore } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -55,7 +55,7 @@ function Dashboard({ session, theme: t, root, open, doctor }) {
 		cell(m.platforms.android),
 		when
 	])], 3);
-	const status = last?.fatal ? t.error(`${t.symbols.fail} ${last.fatal}`) : last?.ok && last.next?.rebuild ? t.warn(`next: ${nextText(last.next)}`) : "";
+	const status = last?.fatal ? t.error(`${t.symbols.fail} ${last.fatal}`) : last?.ok && last.actions?.length ? t.warn(`next: ${last.actions.map((a) => `${ACTION_TEXT[a.kind]} (${a.targets.join(", ")})`).join(", ")}`) : last?.ok && last.next?.rebuild ? t.warn(`next: ${nextText(last.next)}`) : "";
 	const rule = (title) => t.dim(`${t.symbols.rule} ${title} ${t.symbols.rule.repeat(Math.max(3, t.terminal.width - title.length - 4))}`);
 	return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "column",

package/dist/{dev-BYWMP7oC.js → dev-B3lSx5CF.js}

@@ -1,10 +1,10 @@
 import { t as createTheme } from "./theme-uv5bc0aK.js";
 import { n as version } from "./version-bqpIO5sP.js";
-import { h as platformOf, m as moduleNameOf, u as LUCENT_EXTENSION } from "./src-BD7f1_aZ.js";
-import { n as lucentPackages } from "./packages-HyskKIsY.js";
-import { n as nextText, r as plural, t as buildProject } from "./pipeline-CH7-2cxu.js";
+import { D as LUCENT_EXTENSION, M as platformOf, j as moduleNameOf } from "./src-DlICbK91.js";
+import { n as lucentPackages } from "./packages-CSmKeaAh.js";
+import { i as ACTION_TEXT, n as nextText, r as plural, t as buildProject } from "./pipeline-BBY0df_2.js";
 import { t as plainSteps } from "./steps--_h-FFS7.js";
-import { n as systemProbe, t as diagnose } from "./doctor-C0PrfWT6.js";
+import { n as systemProbe, t as diagnose } from "./doctor-CTAX3euc.js";
 import fs from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -25,7 +25,8 @@ function compact(session, out) {
 		}
 		if (last.ok) {
 			const next = last.next?.rebuild ? ` ${t.dim("·")} ${nextText(last.next)}` : "";
-			out.print(`${time} ${t.success(t.symbols.ok)} ${plural(s.modules.length, "module")}  ${t.dim(`${last.ms} ms`)}${next}`);
+			const actions = (last.actions ?? []).map((a) => `${ACTION_TEXT[a.kind]} (${a.targets.join(", ")})`).join(", ");
+			out.print(`${time} ${t.success(t.symbols.ok)} ${plural(s.modules.length, "module")}  ${t.dim(`${last.ms} ms`)}${next}${actions ? ` ${t.dim("·")} ${actions}` : ""}`);
 			return;
 		}
 		out.error(`${time} ${t.error(t.symbols.fail)} ${plural(s.problems.length, "error")}`);
@@ -59,6 +60,7 @@ function createStore(initial = {
 	};
 }
 const DEBOUNCE_MS = 40;
+const ALWAYS_READ = (file) => LUCENT_EXTENSION.test(file) || ["lucent.json", "package.json"].includes(path.basename(file));
 function startSession(root) {
 	const store = createStore();
 	const theme = createTheme({
@@ -68,15 +70,22 @@ function startSession(root) {
 		links: false,
 		width: 80
 	});
-	let building = false;
+	let building;
 	let queued;
 	let timer;
+	let nativeInputs = [];
+	let stopped = false;
+	let readSince = 0;
 	const build = async (force) => {
+		if (stopped) return;
 		if (building) {
+			building.abort();
 			queued = { force: force || !!queued?.force };
 			return;
 		}
-		building = true;
+		const controller = new AbortController();
+		const started = Date.now();
+		building = controller;
 		store.set({
 			...store.get(),
 			building: true,
@@ -90,8 +99,19 @@ function startSession(root) {
 		const at = /* @__PURE__ */ new Date();
 		const r = await buildProject(root, {
 			mode: "build",
-			force
+			force,
+			signal: controller.signal
 		}, plainSteps(() => {}, theme), (n) => notices.push(n));
+		if (r.superseded) {
+			building = void 0;
+			const again = queued ?? { force };
+			queued = void 0;
+			build(again.force);
+			return;
+		}
+		nativeInputs = r.nativeInputs;
+		readSince = started;
+		watch();
 		const failing = /* @__PURE__ */ new Map();
 		for (const d of r.diagnostics) {
 			if (!d.file) continue;
@@ -125,35 +145,52 @@ function startSession(root) {
 				ms: r.ms,
 				ok: r.ok,
 				next: r.ok && !r.upToDate ? r.next : void 0,
+				actions: r.actions,
 				fatal: r.fatal
 			},
-			problems: r.diagnostics.map((d) => ({
+			problems: [...r.diagnostics, ...r.warnings].map((d) => ({
 				...d,
 				source: d.file ? source(d.file) : void 0
 			})),
 			notices
 		});
-		building = false;
+		building = void 0;
 		if (queued) {
 			const again = queued;
 			queued = void 0;
 			build(again.force);
 		}
 	};
-	const changed = (name) => {
-		if (!name || !LUCENT_EXTENSION.test(name) || name.split(path.sep).some((part) => part === "node_modules" || part.startsWith("."))) return;
+	const relevant = (file, dir) => {
+		if (path.relative(dir, file).split(path.sep).some((part) => part === "node_modules" || part.startsWith("."))) return false;
+		return ALWAYS_READ(file) || nativeInputs.some((p) => file === p || file.startsWith(`${p}${path.sep}`));
+	};
+	const changed = (dir, name) => {
+		if (!name || !relevant(path.join(dir, name), dir)) return;
+		const file = path.join(dir, name);
+		if (fs.existsSync(file) && fs.statSync(file).mtimeMs < readSince) return;
 		clearTimeout(timer);
 		timer = setTimeout(() => void build(false), DEBOUNCE_MS);
 	};
-	let packages = [];
-	try {
-		packages = lucentPackages(root).map((p) => p.sources).filter((dir) => path.relative(root, dir).startsWith(".."));
-	} catch {}
-	const watchers = [root, ...packages].map((dir) => fs.watch(dir, { recursive: true }, (_event, name) => changed(name)));
-	store.set({
-		...store.get(),
-		watching: [root, ...packages].map((d) => path.relative(root, d) || ".")
-	});
+	const watchers = /* @__PURE__ */ new Map();
+	const watch = () => {
+		if (stopped) return;
+		let packages = [];
+		try {
+			packages = lucentPackages(root).map((p) => p.dir).filter((dir) => path.relative(root, dir).startsWith(".."));
+		} catch {}
+		const dirs = /* @__PURE__ */ new Set([root, ...packages]);
+		for (const [dir, w] of watchers) if (!dirs.has(dir)) {
+			w.close();
+			watchers.delete(dir);
+		}
+		for (const dir of dirs) if (!watchers.has(dir)) watchers.set(dir, fs.watch(dir, { recursive: true }, (_event, name) => changed(dir, name)));
+		store.set({
+			...store.get(),
+			watching: [...dirs].map((d) => path.relative(root, d) || ".")
+		});
+	};
+	watch();
 	build(false);
 	return {
 		store,
@@ -164,8 +201,10 @@ function startSession(root) {
 			build(true);
 		},
 		stop() {
+			stopped = true;
 			clearTimeout(timer);
-			for (const w of watchers) w.close();
+			building?.abort();
+			for (const w of watchers.values()) w.close();
 		}
 	};
 }
@@ -187,7 +226,7 @@ async function run({ root, flags, out }) {
 		session.stop();
 		return 0;
 	}
-	const { dashboard } = await import("./dashboard-B-NzjjaN.js");
+	const { dashboard } = await import("./dashboard-C8iF5-6T.js");
 	await dashboard({
 		session,
 		theme: out.theme,

package/dist/{diagnostic-BM9sXmwl.js → diagnostic-BvwLZQS1.js}

@@ -12,7 +12,9 @@ function wrap(text, width, indent) {
 }
 function renderDiagnostic(d, source, theme) {
 	const width = theme.terminal.width;
-	const out = [`${`  ${theme.error("error")} ${theme.bold(d.code)}  `}${wrap(d.message.split("\n").join(" "), Math.max(20, width - 2 - 6 - d.code.length - 2), " ".repeat(6 + d.code.length + 4))}`];
+	const label = d.severity === "warning" ? theme.warn("warning") : theme.error("error");
+	const labelWidth = d.severity === "warning" ? 7 : 5;
+	const out = [`${`  ${label} ${theme.bold(d.code)}  `}${wrap(d.message.split("\n").join(" "), Math.max(20, width - 2 - (labelWidth + 1) - d.code.length - 2), " ".repeat(labelWidth + 1 + d.code.length + 4))}`];
 	if (d.file) {
 		out.push("", `    ${theme.dim(d.line ? `${d.file}:${d.line}:${d.column ?? 1}` : d.file)}`);
 		if (source !== void 0 && d.line) out.push(codeFrame(source, {

package/dist/{doctor-C0PrfWT6.js → doctor-CTAX3euc.js}

@@ -1,4 +1,4 @@
-import { n as lucentPackages } from "./packages-HyskKIsY.js";
+import { n as lucentPackages } from "./packages-CSmKeaAh.js";
 import { t as packageManagerOf } from "./package-manager-BnxwCySi.js";
 import fs from "node:fs";
 import path from "node:path";

package/dist/{doctor-DdR4JnVc.js → doctor-CrgOAV5L.js}

@@ -1,6 +1,6 @@
 import { n as version } from "./version-bqpIO5sP.js";
 import { i as table } from "./format-D9fnIMEx.js";
-import { n as systemProbe, t as diagnose } from "./doctor-C0PrfWT6.js";
+import { n as systemProbe, t as diagnose } from "./doctor-CTAX3euc.js";
 //#region src/cli/commands/doctor.ts
 function run({ root, out }) {
 	const checks = diagnose(root, systemProbe(version()));

package/dist/{explain--vV1oaRl.js → explain-Byit07F-.js}

@@ -1,4 +1,4 @@
-import { n as Explanations, r as docsUrl } from "./codes-CIuwXt1S.js";
+import { n as Explanations, r as docsUrl } from "./codes-D-6LxUqD.js";
 import { i as table, r as link } from "./format-D9fnIMEx.js";
 //#region src/cli/commands/explain.ts
 function run({ positionals, out }) {

package/dist/{packages-HyskKIsY.js → packages-CSmKeaAh.js}

@@ -2,35 +2,6 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 //#region ../compiler/src/packages.ts
-function nativeDependencies(packages) {
-	const out = {
-		pods: {},
-		gradle: {},
-		permissions: [],
-		infoPlist: {}
-	};
-	const owners = /* @__PURE__ */ new Map();
-	const merge = (kind, into, key, value, from) => {
-		const id = `${kind} ${key}`;
-		if (into[key] !== void 0 && into[key] !== value) throw new Error(`${kind}${key}: ${owners.get(id)} wants ${into[key]}, ${from} wants ${value}`);
-		into[key] = value;
-		if (!owners.has(id)) owners.set(id, from);
-	};
-	for (const p of packages) {
-		for (const [pod, version] of Object.entries(p.native?.ios?.pods ?? {})) merge("pod ", out.pods, pod, version, p.name);
-		for (const [artifact, version] of Object.entries(p.native?.android?.dependencies ?? {})) merge("", out.gradle, artifact, version, p.name);
-		for (const perm of p.native?.android?.permissions ?? []) if (!out.permissions.includes(perm)) out.permissions.push(perm);
-		for (const [key, value] of Object.entries(p.native?.ios?.infoPlist ?? {})) {
-			merge("Info.plist ", Object.fromEntries(Object.entries(out.infoPlist).map(([k, v]) => [k, v.value])), key, value, p.name);
-			out.infoPlist[key] ??= {
-				value,
-				from: p.name
-			};
-		}
-	}
-	out.permissions.sort();
-	return out;
-}
 const read = (file) => {
 	try {
 		return JSON.parse(fs.readFileSync(file, "utf8"));
@@ -43,14 +14,12 @@ function lucentPackageOf(file) {
 		const pkg = read(path.join(dir, "package.json"));
 		if (pkg) {
 			if (!pkg.lucent || !pkg.name) return void 0;
-			const native = fs.existsSync(path.join(dir, "lucent.json")) ? JSON.parse(fs.readFileSync(path.join(dir, "lucent.json"), "utf8")) : void 0;
 			return {
 				name: pkg.name,
 				version: pkg.version ?? "0.0.0",
 				dir,
 				sources: path.join(dir, pkg.lucent.sources ?? "."),
-				compatible: pkg.lucent.compatible,
-				...native ? { native } : {}
+				compatible: pkg.lucent.compatible
 			};
 		}
 		if (path.dirname(dir) === dir) return void 0;
@@ -147,4 +116,4 @@ function comparator(v, c) {
 	return op === ">=" ? d >= 0 : op === ">" ? d > 0 : op === "<=" ? d <= 0 : d < 0;
 }
 //#endregion
-export { satisfies as a, nativeDependencies as i, lucentPackages as n, lucentVersion as r, lucentPackageOf as t };
+export { satisfies as i, lucentPackages as n, lucentVersion as r, lucentPackageOf as t };