@gtkx/cli 1.5.0 → 2.0.0-beta.1

package/src/codegen/run-codegen.ts

@@ -2,21 +2,23 @@ import { runCodegen as runCodegenCore } from "@gtkx/codegen";
 import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
+    isAgentRulesEnabled,
     resolveElementComponents,
     resolveElementProps,
     resolveLazyElements,
     resolveOmittedProps,
 } from "@gtkx/config/internal";
-import { info, warn } from "@gtkx/utils";
+import { info } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { resolveCatalogProject, synchronizeCatalogs } from "../i18n/catalogs.js";
 import { extractSourceCatalog } from "../i18n/source-messages.js";
-import { emitI18nTypes } from "../i18n/types.js";
-import { resolveDataDir } from "../internal/data-dir.js";
+import { clearI18nTypes, emitI18nTypes } from "../i18n/types.js";
+import { upsertAgentRules } from "../internal/agent-rules.js";
 import { discoverSourceFiles } from "../internal/source-imports.js";
 import { emitSchemaEnv } from "../settings/schema.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
+import { type ReferenceResult, writeReference } from "./reference.js";
 import { type CodegenContext, type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
 
 type RunCodegenOptions = {
@@ -37,12 +39,11 @@ type RunCodegenResult = {
     isRegenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
-    notices: string[];
     duration: number;
-    girPath?: string[] | undefined;
-    configFile?: string | undefined;
-    libraries?: string[] | undefined;
-    future?: string[] | undefined;
+    girPath: string[];
+    configFile: string;
+    libraries: string[];
+    reference?: ReferenceResult | undefined;
 };
 
 type CodegenOptionsInput = {
@@ -50,10 +51,6 @@ type CodegenOptionsInput = {
     libraries: string[];
     girPath: string[];
     elements: Config["elements"];
-    isByteArrayTyped: boolean;
-    isValueUnwrapped: boolean;
-    isFinishTrimmed: boolean;
-    isInoutInPlace: boolean;
 };
 
 type PreparedCodegen = CodegenInputs & { isForced: boolean };
@@ -64,14 +61,6 @@ type EnsureGeneratedOptions = {
     shouldPreserveI18nMetadata?: boolean | undefined;
 };
 
-type RunOptionsInput = {
-    root: string;
-    mode: string | undefined;
-    inputs: CodegenInputs | null;
-    resolved: LoadedConfig;
-    shouldPreserveI18nMetadata: boolean | undefined;
-};
-
 const GIR_PATH_MISSING_MESSAGE =
     "No GIR search paths available. Install gobject-introspection " +
     "(Linux: `sudo dnf install gobject-introspection-devel` or `sudo apt install libgirepository1.0-dev`), " +
@@ -88,13 +77,9 @@ const removeShadowingStores = (cwd: string): void => {
     removeStores(getShadowingStorePaths(cwd));
 };
 
-const codegenOptions = ({ store, libraries, girPath, elements, ...future }: CodegenOptionsInput) => ({
+const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsInput) => ({
     libraries,
     girPath,
-    isByteArrayTyped: future.isByteArrayTyped,
-    isValueUnwrapped: future.isValueUnwrapped,
-    isFinishTrimmed: future.isFinishTrimmed,
-    isInoutInPlace: future.isInoutInPlace,
     gi: {
         storeDir: store.giStoreDir,
         linkDir: store.giLinkDir,
@@ -108,50 +93,30 @@ const codegenOptions = ({ store, libraries, girPath, elements, ...future }: Code
                     linkDir: store.jsxLinkDir,
                     version: store.react.version,
                 },
-    reactSubexports: store.react?.subexports ?? [],
     userComponents: resolveElementComponents(elements),
     userProps: resolveElementProps(elements),
     userLazyElements: resolveLazyElements(elements),
     userOmittedProps: resolveOmittedProps(elements),
 });
 
-const enabledFutureFlags = (config: Config): string[] =>
-    Object.entries(config.future ?? {})
-        .filter(([, value]) => value === true)
-        .map(([name]) => name);
-
 const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     isRegenerated: false,
     namespaces: 0,
     intrinsicElements: 0,
-    notices: [],
     duration: 0,
     girPath: [],
     configFile,
     libraries: [],
 });
 
-const warnNotices = (notices: string[]): void => {
-    for (const notice of notices) {
-        warn(notice);
-    }
-};
-
-const regeneratedStorePaths = (store: CodegenStore): string[] => {
-    if (store.react === null) {
-        return [store.giStoreDir, store.giLinkDir];
-    }
-
-    return [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir];
-};
-
 const clearGeneratedStores = (store: CodegenStore): void => {
-    removeStores(regeneratedStorePaths(store));
+    removeStores(
+        store.react === null
+            ? [store.giStoreDir, store.giLinkDir]
+            : [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir],
+    );
 };
 
-const resolveLoadedConfig = async (options: RunCodegenOptions, cwd: string): Promise<LoadedConfig> =>
-    options.resolved ?? (await loadConfig(cwd, { mode: options.mode }));
-
 const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config): PreparedCodegen => {
     const { girPath, libraries, store } = options.inputs ?? resolveCodegenInputs(cwd, config);
 
@@ -166,9 +131,9 @@ const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config)
 
 const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenResult> => {
     const cwd = options.cwd ?? process.cwd();
-    const { config, configFile } = await resolveLoadedConfig(options, cwd);
+    const { config, configFile } = options.resolved ?? (await loadConfig(cwd, { mode: options.mode }));
     await syncI18n(cwd, config.applicationId, options.shouldPreserveI18nMetadata);
-    syncSchemaEnv(cwd, config.future?.v2ResourceImports === true);
+    emitSchemaEnv(cwd);
 
     if (config.codegen === false) {
         removeShadowingStores(cwd);
@@ -183,31 +148,25 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
     }
 
     const result = await runCodegenCore({
-        ...codegenOptions({
-            store,
-            libraries,
-            girPath,
-            elements: config.elements,
-            isByteArrayTyped: config.future?.v2ByteArrays === true,
-            isValueUnwrapped: config.future?.v2ValueReturns === true,
-            isFinishTrimmed: config.future?.v2FinishResults === true,
-            isInoutInPlace: config.future?.v2InoutReturns === true,
-        }),
+        ...codegenOptions({ store, libraries, girPath, elements: config.elements }),
         isForced,
     });
 
-    warnNotices(result.notices);
+    const reference = await writeReference({ root: cwd, config, girPath, libraries, isForced });
+
+    if (isAgentRulesEnabled(config)) {
+        upsertAgentRules(cwd);
+    }
 
     return {
         isRegenerated: result.isRegenerated,
         namespaces: result.namespaces,
         intrinsicElements: result.intrinsicElements,
-        notices: result.notices,
         duration: result.duration,
         girPath,
         configFile,
         libraries,
-        future: enabledFutureFlags(config),
+        reference,
     };
 };
 
@@ -219,16 +178,16 @@ const syncI18n = async (
     const project = resolveCatalogProject(root, applicationId);
 
     if (project === null) {
-        emitI18nTypes(root, [], false);
+        clearI18nTypes(root);
 
         return;
     }
 
     const srcDir = join(root, "src");
     const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : root);
-    const catalog = await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
+    await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
     synchronizeCatalogs(project);
-    emitI18nTypes(root, catalog.messages);
+    await emitI18nTypes(root);
 };
 
 const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> => {
@@ -241,11 +200,6 @@ const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> =
     }
 };
 
-const syncSchemaEnv = (cwd: string, isV2ResourceImports = false): void => {
-    const dataDir = isV2ResourceImports ? null : resolveDataDir(cwd);
-    emitSchemaEnv(cwd, dataDir, isV2ResourceImports);
-};
-
 const resolveInputsOrNull = (cwd: string, config: Config): CodegenInputs | null => {
     try {
         return resolveCodegenInputs(cwd, config);
@@ -264,20 +218,6 @@ const maybeAnnounceStale = (shouldAnnounce: boolean | undefined, inputs: Codegen
     }
 };
 
-const getRunOptions = ({
-    root,
-    mode,
-    inputs,
-    resolved,
-    shouldPreserveI18nMetadata,
-}: RunOptionsInput): RunCodegenOptions => {
-    if (inputs === null) {
-        return { cwd: root, mode, resolved, shouldPreserveI18nMetadata };
-    }
-
-    return { cwd: root, mode, inputs, resolved, shouldPreserveI18nMetadata };
-};
-
 const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
     options.shouldAnnounce === true && process.env.GTKX_DISABLE_PREFLIGHT === "1";
 
@@ -298,13 +238,13 @@ const generate = async (context: CodegenContext, options: EnsureGeneratedOptions
     maybeAnnounceStale(options.shouldAnnounce, inputs);
     const resolved = { config: context.config, configFile: context.configFile };
 
-    const result = await runCodegen(getRunOptions({
-        root: context.root,
+    const result = await runCodegen({
+        cwd: context.root,
         mode: options.mode,
-        inputs,
         resolved,
         shouldPreserveI18nMetadata: options.shouldPreserveI18nMetadata,
-    }));
+        ...(inputs !== null && { inputs }),
+    });
 
     return result.isRegenerated;
 };

package/src/codegen/store-resolver.ts

@@ -1,6 +1,6 @@
 import { resolveStore } from "@gtkx/codegen";
 import { type Config, loadConfig } from "@gtkx/config";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -16,39 +16,23 @@ type CodegenStore = {
 
 type CodegenReactPackage = {
     version: string;
-    subexports: string[];
 };
 
-type ResolvedPackage = { dir: string; version: string };
-
 type CodegenContext = {
     root: string;
     config: Config;
     configFile: string;
 };
 
-const readVersion = (packageJsonPath: string): string => {
-    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { version?: string };
-
-    return parsed.version ?? "0.0.0";
-};
-
-const resolvePackage = (require: NodeJS.Require, dir: string, packageName: string): ResolvedPackage | null => {
+const hasPackage = (require: NodeJS.Require, dir: string, packageName: string): boolean => {
     try {
-        const real = realpathSync(require.resolve(`${packageName}/package.json`));
+        require.resolve(`${packageName}/package.json`);
 
-        return { dir: dirname(real), version: readVersion(real) };
+        return true;
     } catch {
         const unscoped = packageName.replace(/^@[^/]+\//, "");
-        const workspacePkg = join(dir, "packages", unscoped, "package.json");
-
-        if (!existsSync(workspacePkg)) {
-            return null;
-        }
-
-        const real = realpathSync(workspacePkg);
 
-        return { dir: dirname(real), version: readVersion(real) };
+        return existsSync(join(dir, "packages", unscoped, "package.json"));
     }
 };
 
@@ -57,12 +41,12 @@ const siblingStore = (giDir: string): string => join(dirname(giDir), "jsx");
 const resolveCodegenStore = (dir: string): CodegenStore => {
     const require = createRequire(pathToFileURL(join(dir, "__gtkx_resolver__.js")).href);
 
-    if (resolvePackage(require, dir, "@gtkx/native") === null) {
+    if (!hasPackage(require, dir, "@gtkx/native")) {
         throw new Error("Cannot resolve @gtkx/native from the project; is it installed?");
     }
 
     const store = resolveStore(dir);
-    const hasReactRuntime = resolvePackage(require, dir, "react") !== null;
+    const hasReactRuntime = hasPackage(require, dir, "react");
 
     return {
         giStoreDir: store.gi.storeDir,
@@ -72,7 +56,7 @@ const resolveCodegenStore = (dir: string): CodegenStore => {
         runtimeVersion: store.gi.version,
         react:
             hasReactRuntime && store.jsx !== null
-                ? { version: store.jsx.version, subexports: store.reactSubexports }
+                ? { version: store.jsx.version }
                 : null,
     };
 };

package/src/commands/docs.ts

@@ -1,19 +1,11 @@
-import {
-    type ElementProps,
-    mergeOmittedProps,
-    type OmittedProps,
-    readBuiltinElements,
-    resolveGirPath,
-    resolveLibraries,
-    resolveStore,
-} from "@gtkx/codegen";
+import { mergeOmittedProps, resolveGirPath, resolveLibraries } from "@gtkx/codegen";
 import { writeDocs } from "@gtkx/codegen/internal";
 import { loadConfig } from "@gtkx/config";
 import { resolveOmittedProps } from "@gtkx/config/internal";
-import { info } from "@gtkx/utils";
+import { info, isPathInside } from "@gtkx/utils";
 import { defineCommand } from "citty";
-import { existsSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { resolve } from "node:path";
+import { resolveDocsElements } from "../internal/docs-elements.js";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
 const docs = defineCommand({
@@ -65,7 +57,7 @@ const docs = defineCommand({
             );
         }
 
-        const libraries = resolveLibraries(config.libraries, girPath);
+        const libraries = resolveLibraries(config.libraries);
         const startedAt = Date.now();
         const outDir = resolveOutDir(cwd, args.out);
         const builtin = await resolveDocsElements(cwd);
@@ -78,10 +70,6 @@ const docs = defineCommand({
             props: builtin.props,
             omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
             isForced: args.force,
-            isByteArrayTyped: config.future?.v2ByteArrays === true,
-            isValueUnwrapped: config.future?.v2ValueReturns === true,
-            isFinishTrimmed: config.future?.v2FinishResults === true,
-            isInoutInPlace: config.future?.v2InoutReturns === true,
         });
 
         if (!isRegenerated) {
@@ -99,12 +87,6 @@ const docs = defineCommand({
     },
 });
 
-const isBelow = (parent: string, child: string): boolean => {
-    const path = relative(parent, child);
-
-    return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
-};
-
 const outDirReason = (cwd: string, out: string, outDir: string): string => {
     if (out.trim() === "") {
         return "it was empty, which names the project root itself";
@@ -120,7 +102,7 @@ const outDirReason = (cwd: string, out: string, outDir: string): string => {
 const resolveOutDir = (cwd: string, out: string): string => {
     const outDir = out.trim() === "" ? cwd : resolve(cwd, out);
 
-    if (isBelow(cwd, outDir)) {
+    if (isPathInside(cwd, outDir)) {
         return outDir;
     }
 
@@ -130,16 +112,4 @@ const resolveOutDir = (cwd: string, out: string): string => {
     );
 };
 
-const resolveDocsElements = async (cwd: string): Promise<{ props: ElementProps; omittedProps: OmittedProps }> => {
-    const { gi, reactSubexports } = resolveStore(cwd);
-
-    if (!existsSync(gi.storeDir)) {
-        return { props: {}, omittedProps: {} };
-    }
-
-    const { props, omittedProps } = await readBuiltinElements(reactSubexports, gi.storeDir);
-
-    return { props, omittedProps };
-};
-
 export { docs };

package/src/commands/mcp.ts

@@ -0,0 +1,81 @@
+import { info } from "@gtkx/utils";
+import { defineCommand } from "citty";
+import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
+import { type ClientName, type ClientResult, CLIENTS, isClientName, writeClientConfig } from "../mcp/client-config.js";
+
+const clientList = CLIENTS.map((client) => client.name).join(", ");
+
+const init = defineCommand({
+    meta: {
+        name: "init",
+        description: "Write the gtkx MCP server into an editor's configuration file",
+    },
+    args: {
+        client: {
+            type: "string",
+            description: `Which editor to configure: one of ${clientList}`,
+            required: true,
+        },
+        ...cwdArg,
+    },
+    run({ args }) {
+        const cwd = resolveCwd(args);
+        const name = args.client;
+
+        if (!isClientName(name)) {
+            throw new Error(`Unknown --client "${name}". Pass one of ${clientList}.`);
+        }
+
+        report(name, writeClientConfig(cwd, name));
+    },
+});
+
+const mcp = defineCommand({
+    meta: {
+        name: "mcp",
+        description: "Run the MCP server that exposes this project's running app and generated API reference",
+    },
+    args: {
+        tools: {
+            type: "string",
+            description:
+                "Comma-separated tool name patterns to register, `*` matching any run of characters and a " +
+                "leading `!` excluding. Overrides `mcp.tools` in gtkx.config.ts",
+        },
+        "read-only": {
+            type: "boolean",
+            description: "Register only the tools that read state, leaving out the ones that drive the app",
+        },
+        ...cwdArg,
+    },
+    subCommands: { init },
+    async run({ args }) {
+        const { runMcpServer } = await import("@gtkx/mcp/server");
+
+        await runMcpServer({
+            cwd: resolveCwd(args),
+            ...(args.tools !== undefined && { tools: splitPatterns(args.tools) }),
+            ...(args["read-only"] !== undefined && { isReadOnly: args["read-only"] }),
+        });
+    },
+});
+
+const splitPatterns = (value: string): string[] =>
+    value.split(",").map((pattern) => pattern.trim()).filter((pattern) => pattern.length > 0);
+
+const report = (name: ClientName, result: ClientResult): void => {
+    if (result.kind === "manual") {
+        info(`mcp: ${name} keeps its servers in ${result.path}, which is outside this project. Add:`);
+
+        for (const line of result.snippet.split("\n")) {
+            info(`mcp:   ${line}`);
+        }
+
+        return;
+    }
+
+    info(`mcp: ${result.isCreated ? "created" : "updated"} ${result.path} for ${name}`);
+    info("mcp: restart the editor for it to pick the server up");
+};
+
+export { mcp };

package/src/deploy/freedesktop/copyright.ts

@@ -1,6 +1,6 @@
-import { readFileSync } from "node:fs";
 import type { DeploySettings, Notice, NoticeSection } from "../types.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
+import { readLicenseText } from "../notices/text.js";
 
 type FileStanza = {
     settings: DeploySettings;
@@ -30,18 +30,6 @@ const foldedField = (name: string, lines: string[]): string[] => {
     return first === undefined ? [] : [`${name}: ${first}`, ...rest.map((line) => indentLine(line))];
 };
 
-const licenseText = (licenseFile: string | null): string | null => {
-    if (licenseFile === null) {
-        return null;
-    }
-
-    try {
-        return readFileSync(licenseFile, "utf8").trimEnd();
-    } catch {
-        return null;
-    }
-};
-
 const shortName = (license: string): string =>
     license
         .replaceAll(SPDX_GROUPING, " ")
@@ -159,7 +147,7 @@ const applicationStanza = (settings: DeploySettings, text: string | null): strin
 ];
 
 const renderCopyright = (settings: DeploySettings, sections: NoticeSection[]): string => {
-    const own = licenseText(settings.paths.licenseFile);
+    const own = settings.paths.licenseFile === null ? null : readLicenseText(settings.paths.licenseFile);
     const reproduced: Set<string> = new Set(own === null ? [] : [own]);
 
     const stanzas = filePatterns(sections).flatMap((files) =>

package/src/deploy/freedesktop/xml.ts

@@ -1,3 +1,5 @@
+import XMLBuilder from "fast-xml-builder";
+
 type XmlNode = {
     tag: string;
     attributes?: Record<string, string>;
@@ -5,23 +7,26 @@ type XmlNode = {
     text?: string;
 };
 
-const XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>';
-const INDENT = " ".repeat(4);
+type OrderedNode = Record<string, unknown>;
 
-const ESCAPES: Record<string, string> = {
-    '"': "&quot;",
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-};
+const XML_ENCODING = ["UTF", "8"].join("-");
 
-const escapeXml = (value: string): string =>
-    value.replaceAll(/["&<>]/g, (character) => ESCAPES[character] ?? character);
+const builder = new XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    indentBy: " ".repeat(4),
+    preserveOrder: true,
+    suppressEmptyNode: true,
+});
 
-const renderAttributes = (attributes: Record<string, string> | undefined): string =>
-    Object.entries(attributes ?? {})
-        .map(([key, value]) => ` ${key}="${escapeXml(value)}"`)
-        .join("");
+const orderedNode = (node: XmlNode): OrderedNode => ({
+    [node.tag]: node.text === undefined
+        ? (node.children ?? []).map((child) => orderedNode(child))
+        : [{ "#text": node.text }],
+    ...(node.attributes && {
+        ":@": Object.fromEntries(Object.entries(node.attributes).map(([key, value]) => [`@_${key}`, value])),
+    }),
+});
 
 const element = (tag: string, attributes: Record<string, string>, children: XmlNode[]): XmlNode => ({
     tag,
@@ -31,23 +36,10 @@ const element = (tag: string, attributes: Record<string, string>, children: XmlN
 
 const text = (tag: string, value: string): XmlNode => ({ tag, text: value });
 
-const renderNode = (node: XmlNode, depth: number): string[] => {
-    const padding = INDENT.repeat(depth);
-    const open = `${padding}<${node.tag}${renderAttributes(node.attributes)}`;
-
-    if (node.text !== undefined) {
-        return [`${open}>${escapeXml(node.text)}</${node.tag}>`];
-    }
-
-    const children = node.children ?? [];
-
-    if (children.length === 0) {
-        return [`${open}/>`];
-    }
-
-    return [`${open}>`, ...children.flatMap((child) => renderNode(child, depth + 1)), `${padding}</${node.tag}>`];
-};
-
-const renderDocument = (root: XmlNode): string => [XML_DECLARATION, ...renderNode(root, 0), ""].join("\n");
+const renderDocument = (root: XmlNode): string =>
+    `${builder.build([
+        { "?xml": [{ "#text": "" }], ":@": { "@_version": "1.0", "@_encoding": XML_ENCODING } },
+        orderedNode(root),
+    ])}\n`;
 
 export { element, renderDocument, text, type XmlNode };

package/src/deploy/node-runtime/license.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { readLicenseText } from "../notices/text.js";
 
 const LICENSE_FILENAME = "LICENSE";
 const NODE_MARKER = "Node.js";
@@ -10,13 +10,7 @@ const licenseCandidates = (binary: string): string[] => {
     return [join(dir, LICENSE_FILENAME), join(dir, "..", LICENSE_FILENAME)];
 };
 
-const isNodeLicense = (path: string): boolean => {
-    try {
-        return readFileSync(path, "utf8").includes(NODE_MARKER);
-    } catch {
-        return false;
-    }
-};
+const isNodeLicense = (path: string): boolean => readLicenseText(path)?.includes(NODE_MARKER) === true;
 
 const licenseBesideNode = (binary: string): string | null =>
     licenseCandidates(binary).find((candidate) => isNodeLicense(candidate)) ?? null;

package/src/deploy/notices/gtkx.ts

@@ -44,7 +44,7 @@ const summaryFor = (settings: DeploySettings, packages: BundledPackage[]): strin
         "Section 3.2(a) asks that whoever receives an executable form be told how to obtain the source code,",
         "which is what the source pointer below is for: it leads to the release these files were built from.",
         `The addon also statically links Rust crates GTKX did not write, so ${lib}/${NATIVE_FILENAME} is not`,
-        `${LICENSE_NAME} alone. The second notice below names the licenses those crates carry; it does not`,
+        `${LICENSE_NAME} alone. The crates notice below names the licenses those crates carry; it does not`,
         `reproduce their texts, and ${CRATES_MANIFEST} in the source pointed at records which crates went in`,
         "and at which versions.",
         ...modulesLine(packages),

package/src/deploy/notices/libraries.ts

@@ -36,7 +36,8 @@ const SUMMARY = [
     "their own terms; this package does not distribute them at all.",
     "The GTKX native addon does link GLib, GObject and GIO dynamically against the copies already installed",
     "on the system, which makes the addon a work that uses those libraries, and section 6 of the LGPL asks",
-    "such a work to carry three things. This is the notice it asks for. The license itself is published at",
+    "such a work to carry a notice, the license, and the copyright notices. This is the notice it asks for,",
+    "and the license itself is published at",
     `${LGPL_URL},`,
     "and the copyright notice of each library is published with its sources, at the address listed beside",
     "it below. Linking against an installed shared library is the mechanism section 6(b) allows, so the",