@getpaseo/cli 0.4.0-beta.2 → 0.5.0-beta.1

package/dist/cli.js

@@ -3,6 +3,8 @@ import { createAgentCommand } from "./commands/agent/index.js";
 import { createDaemonCommand } from "./commands/daemon/index.js";
 import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
+import { createPluginCommand } from "./commands/plugin/index.js";
+import { createProjectCommand } from "./commands/project/index.js";
 import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
 import { createScriptCommand } from "./commands/script/index.js";
@@ -15,6 +17,7 @@ import { createHooksCommand } from "./commands/hooks.js";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
 import { runStatusCommand as runDaemonStatusCommand } from "./commands/daemon/status.js";
 import { runRestartCommand as runDaemonRestartCommand } from "./commands/daemon/restart.js";
+import { runDaemonReloadCommand } from "./commands/daemon/reload.js";
 import { addLsOptions, runLsCommand } from "./commands/agent/ls.js";
 import { addRunOptions, runRunCommand } from "./commands/agent/run.js";
 import { addLogsOptions, runLogsCommand } from "./commands/agent/logs.js";
@@ -79,6 +82,7 @@ export function createCli() {
         .description('Show local daemon status (alias for "paseo daemon status")'))
         .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
         .action(withOutput(runDaemonStatusCommand));
+    addJsonAndDaemonHostOptions(program.command("reload").description('Reload daemon config (alias for "paseo daemon reload")')).action(withOutput(runDaemonReloadCommand));
     addJsonOption(program
         .command("restart")
         .description('Restart local daemon (alias for "paseo daemon restart")'))
@@ -116,9 +120,11 @@ export function createCli() {
     program.addCommand(createPermitCommand());
     // Provider commands
     program.addCommand(createProviderCommand());
+    program.addCommand(createPluginCommand());
     // Speech model commands
     program.addCommand(createSpeechCommand());
     // Workspace commands
+    program.addCommand(createProjectCommand());
     program.addCommand(createWorkspaceCommand());
     // COMPAT(worktreeCli): legacy command alias added before workspace was the product unit.
     // Added in v0.2.0; remove after 2027-01-17.

package/dist/commands/daemon/index.js

@@ -5,8 +5,9 @@ import { runStopCommand } from "./stop.js";
 import { runRestartCommand } from "./restart.js";
 import { runSetPasswordCommand } from "./set-password.js";
 import { pairCommand } from "./pair.js";
+import { runDaemonReloadCommand } from "./reload.js";
 import { withOutput } from "../../output/index.js";
-import { addJsonOption } from "../../utils/command-options.js";
+import { addJsonAndDaemonHostOptions, addJsonOption } from "../../utils/command-options.js";
 function resolveHostnamesOption(hostnames, allowedHosts) {
     if (typeof hostnames === "string")
         return hostnames;
@@ -18,6 +19,7 @@ export function createDaemonCommand() {
     const daemon = new Command("daemon").description("Manage the Paseo daemon");
     daemon.addCommand(startCommand());
     daemon.addCommand(pairCommand());
+    addJsonAndDaemonHostOptions(daemon.command("reload").description("Reload config.json without restarting the daemon")).action(withOutput(runDaemonReloadCommand));
     addJsonOption(daemon.command("status").description("Show local daemon status"))
         .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
         .action(withOutput(runStatusCommand));

package/dist/commands/daemon/reload.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export interface DaemonReloadResult {
+    appliedPaths: string[];
+    restartRequiredPaths: string[];
+    overrideControlledPaths: string[];
+}
+export declare const daemonReloadSchema: OutputSchema<DaemonReloadResult>;
+export declare function runDaemonReloadCommand(options: CommandOptions, _command: Command): Promise<SingleResult<DaemonReloadResult>>;
+//# sourceMappingURL=reload.d.ts.map

package/dist/commands/daemon/reload.js

@@ -0,0 +1,36 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const daemonReloadSchema = {
+    idField: () => "daemon-config",
+    columns: [],
+    renderHuman(result) {
+        if (result.type !== "single")
+            return "";
+        const lines = ["Configuration reloaded."];
+        if (result.data.restartRequiredPaths.length > 0) {
+            lines.push("", "Warning: These changes require a daemon restart:", ...result.data.restartRequiredPaths.map((path) => `  ${path}`), "", "Run: paseo daemon restart");
+        }
+        if (result.data.overrideControlledPaths.length > 0) {
+            lines.push("", "Warning: These settings are controlled by daemon launch overrides:", ...result.data.overrideControlledPaths.map((path) => `  ${path}`));
+        }
+        return lines.join("\n");
+    },
+};
+export async function runDaemonReloadCommand(options, _command) {
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const payload = await client.reloadDaemonConfig();
+        return {
+            type: "single",
+            data: {
+                appliedPaths: payload.appliedPaths,
+                restartRequiredPaths: payload.restartRequiredPaths,
+                overrideControlledPaths: payload.overrideControlledPaths,
+            },
+            schema: daemonReloadSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=reload.js.map

package/dist/commands/hub/deploy.d.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 import { type SingleResult } from "../../output/index.js";
 import { HubHttpClient, type HubInstallResult, type HubValidationResult } from "./hub-client/index.js";
 import { type HubCredentialStore } from "./credentials.js";
+import { type HubDeployBundle } from "./deploy-bundle.js";
 import { type HubReporter } from "./reporter.js";
 export interface HubDeployOptions {
     project?: string;
@@ -10,7 +11,7 @@ export interface HubDeployOptions {
     dryRun?: boolean;
     json?: boolean;
 }
-interface HubDeployEnvironment {
+export interface HubDeployEnvironment {
     cwd: string;
     env: Readonly<Record<string, string | undefined>>;
     credentials?: HubCredentialStore;
@@ -33,6 +34,7 @@ interface HubDryRunResult extends HubValidationResult {
     workflows: number;
 }
 export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
+export declare function runHubDeployBundle(options: HubDeployOptions, deployInput: HubDeployBundle, environment: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
 export declare function addHubDeployCommand(hub: Command, dependencies: HubDeployCommandDependencies): void;
 export {};
 //# sourceMappingURL=deploy.d.ts.map

package/dist/commands/hub/deploy.js

@@ -32,6 +32,13 @@ export async function runHubDeploy(options, environment = {
     credentials: new PrivateHubCredentialStore(),
     hub: new HubHttpClient(),
 }) {
+    const deployInput = await discoverHubBundle({
+        cwd: environment.cwd,
+        ...(options.project === undefined ? {} : { project: options.project }),
+    });
+    return runHubDeployBundle(options, deployInput, environment);
+}
+export async function runHubDeployBundle(options, deployInput, environment) {
     const credentials = environment.credentials ?? new PrivateHubCredentialStore(environment.env);
     const resolution = {
         options: { origin: options.hub, apiKey: options.apiKey },
@@ -39,10 +46,6 @@ export async function runHubDeploy(options, environment = {
         credentials,
     };
     const origin = resolveHubOrigin(resolution);
-    const deployInput = await discoverHubBundle({
-        cwd: environment.cwd,
-        ...(options.project === undefined ? {} : { project: options.project }),
-    });
     const action = options.dryRun === true ? "Validating" : "Deploying";
     reportHubProgress(environment.reporter ?? processHubReporter, options, `${action} ${deployInput.projectSlug} ${options.dryRun === true ? "against" : "to"} ${origin}`);
     const credential = resolveHubCredential({ ...resolution, origin });

package/dist/commands/hub/disconnect.js

@@ -10,13 +10,13 @@ export function runHubDisconnect(options, dependencies) {
             reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${current.hubOrigin}`);
         }
         const response = await client.disconnectHub(options.force ?? false);
-        return hubStatusResult(response.status, response.warning, current.hubOrigin);
+        return hubStatusResult(response.status, response.warning);
     });
 }
 export function addHubDisconnectCommand(parent, dependencies) {
     addJsonAndDaemonHostOptions(parent
         .command("disconnect")
-        .option("--force", "Remove local authority even if the Hub is offline")).action(withOutput(async (...args) => {
+        .option("--force", "Remove local authority without notifying the Hub")).action(withOutput(async (...args) => {
         const options = args.at(-2);
         return runHubDisconnect(options, dependencies);
     }));

package/dist/commands/hub/hub-client/index.d.ts

@@ -1,6 +1,6 @@
 import type { HubBundleFile } from "../deploy-bundle.js";
-import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubProject, type HubValidationResult } from "./internal/contracts.js";
-export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubProject, HubValidationResult, } from "./internal/contracts.js";
+import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubConfigurationResources, type HubProject, type HubValidationResult } from "./internal/contracts.js";
+export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubProject, HubValidationResult, } from "./internal/contracts.js";
 interface HubConfigurationInput {
     origin: string;
     apiKey: string;
@@ -11,6 +11,7 @@ export declare class HubHttpClient {
     startCliAuthorization(origin: string): Promise<CliAuthorization>;
     pollCliAuthorization(origin: string, deviceCode: string, timeoutMilliseconds: number): Promise<CliAuthorizationPoll>;
     listProjects(origin: string, apiKey: string): Promise<HubProject[]>;
+    listConfigurationResources(origin: string, apiKey: string): Promise<HubConfigurationResources>;
     installConfiguration(input: HubConfigurationInput): Promise<HubInstallResult>;
     validateConfiguration(input: HubConfigurationInput): Promise<HubValidationResult>;
     issueEnrollmentToken(origin: string, apiKey: string): Promise<string>;

package/dist/commands/hub/hub-client/index.js

@@ -1,5 +1,5 @@
 import { HubCommandError } from "../error.js";
-import { authorizationPollSchema, authorizationSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
+import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
 import { requestHub } from "./internal/transport.js";
 export class HubHttpClient {
     startCliAuthorization(origin) {
@@ -45,6 +45,17 @@ export class HubHttpClient {
         });
         return response.projects;
     }
+    listConfigurationResources(origin, apiKey) {
+        return requestHub({
+            origin,
+            path: "/api/v1/configuration-resources",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: configurationResourcesSchema,
+            failureMessage: "Hub configuration resource listing failed",
+        });
+    }
     installConfiguration(input) {
         return requestHub({
             origin: input.origin,

package/dist/commands/hub/hub-client/internal/contracts.d.ts

@@ -42,6 +42,26 @@ export declare const projectsResponseSchema: z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const configurationResourcesSchema: z.ZodObject<{
+    daemons: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strict>>;
+    github: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        accountLogin: z.ZodString;
+        accountType: z.ZodString;
+        repositories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    discord: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        guildName: z.ZodString;
+    }, z.core.$strict>>;
+    slack: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        teamName: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const installResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     version: z.ZodNumber;
@@ -59,6 +79,7 @@ export declare const enrollmentTokenSchema: z.ZodObject<{
 export type CliAuthorization = z.infer<typeof authorizationSchema>;
 export type CliAuthorizationPoll = z.infer<typeof authorizationPollSchema>;
 export type HubProject = z.infer<typeof projectSchema>;
+export type HubConfigurationResources = z.infer<typeof configurationResourcesSchema>;
 export type HubInstallResult = z.infer<typeof installResponseSchema>;
 export type HubValidationResult = z.infer<typeof validationResponseSchema>;
 export {};

package/dist/commands/hub/hub-client/internal/contracts.js

@@ -30,6 +30,21 @@ const projectSchema = z
     .object({ id: z.string().uuid(), slug: z.string().min(1), name: z.string().min(1) })
     .strict();
 export const projectsResponseSchema = z.object({ projects: z.array(projectSchema) }).strict();
+export const configurationResourcesSchema = z
+    .object({
+    daemons: z.array(z.object({ id: z.string().uuid(), slug: z.string().min(1) }).strict()),
+    github: z.array(z
+        .object({
+        slug: z.string().min(1),
+        accountLogin: z.string().min(1),
+        accountType: z.string().min(1),
+        repositories: z.array(z.string().min(1)),
+    })
+        .strict()),
+    discord: z.array(z.object({ slug: z.string().min(1), guildName: z.string().min(1) }).strict()),
+    slack: z.array(z.object({ slug: z.string().min(1), teamName: z.string().min(1) }).strict()),
+})
+    .strict();
 export const installResponseSchema = z
     .object({
     projectSlug: z.string().min(1),

package/dist/commands/hub/hub-client/internal/problem.js

@@ -35,9 +35,15 @@ export async function hubRequestFailure(response, failureMessage, apiKey) {
         return new HubCommandError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
     }
     const title = parsed.data.title ?? `${failureMessage} with HTTP ${response.status}`;
-    const message = parsed.data.detail === undefined ? title : `${title}: ${parsed.data.detail}`;
     const details = formatFieldIssues(parsed.data.errors, parsed.data.issues);
-    const code = response.status === 422 ? "HUB_VALIDATION_FAILED" : "HUB_REQUEST_FAILED";
+    const message = details !== undefined || parsed.data.detail === undefined
+        ? title
+        : `${title}: ${parsed.data.detail}`;
+    let code = "HUB_REQUEST_FAILED";
+    if (response.status === 422)
+        code = "HUB_VALIDATION_FAILED";
+    if (response.status === 404)
+        code = "HUB_NOT_FOUND";
     return new HubCommandError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
 }
 function formatFieldIssues(errors, issues) {
@@ -57,6 +63,13 @@ function formatFieldIssues(errors, issues) {
 function formatIssuePath(path) {
     if (path === undefined || typeof path === "string")
         return path;
+    const [file, ...fieldPath] = path;
+    if (typeof file === "string" && file.startsWith(".paseo/") && fieldPath.length > 0) {
+        return `${file}: ${formatPathSegments(fieldPath)}`;
+    }
+    return formatPathSegments(path) || undefined;
+}
+function formatPathSegments(path) {
     let formatted = "";
     for (const segment of path) {
         if (typeof segment === "number")
@@ -64,7 +77,7 @@ function formatIssuePath(path) {
         else
             formatted += formatted.length === 0 ? segment : `.${segment}`;
     }
-    return formatted || undefined;
+    return formatted;
 }
 function redactSecret(value, secret) {
     return secret === undefined ? value : value.split(secret).join("[redacted]");

package/dist/commands/hub/index.js

@@ -14,6 +14,7 @@ import { addHubProjectsCommand } from "./projects.js";
 import { processHubReporter } from "./reporter.js";
 import { hubStatusResult } from "./status-output.js";
 import { addHubResolutionHelp } from "./help.js";
+import { addHubInitCommand } from "./init.js";
 function productionEnvironment() {
     const env = process.env;
     const hub = new HubHttpClient();
@@ -37,6 +38,7 @@ export function createHubCommand(overrides = {}) {
         flow: environment.login,
         reporter: environment.reporter,
     });
+    addHubInitCommand(hub, environment);
     addHubConnectCommand(hub, {
         env: environment.env,
         credentials: environment.credentials,

package/dist/commands/hub/init-plan.d.ts

@@ -0,0 +1,50 @@
+import type { HubDeployBundle } from "./deploy-bundle.js";
+import type { HubProject } from "./hub-client/index.js";
+import type { HubStatus } from "./daemon-client.js";
+export type HubInitProvider = "github" | "slack" | "discord";
+export type HubInitProjectResolution = {
+    kind: "none";
+} | {
+    kind: "selected";
+    project: HubProject;
+} | {
+    kind: "choose";
+    projects: readonly HubProject[];
+};
+export type HubInitConnectionResolution = {
+    kind: "connected";
+    daemonId: string;
+} | {
+    kind: "pending";
+    state: "connecting" | "reconnecting";
+} | {
+    kind: "connect";
+} | {
+    kind: "conflict";
+    origin: string;
+};
+export interface HubInitOpeningPlan {
+    replaceExisting: boolean;
+    steps: readonly ("login" | "connect" | "project" | "scaffold")[];
+}
+export interface HubInitScaffoldInput {
+    cwd: string;
+    daemonSlug: string;
+    provider: HubInitProvider;
+    providerFilters: Readonly<Record<string, string>>;
+}
+export interface HubInitScaffold {
+    hub: string;
+    workflowPath: string;
+    workflow: string;
+    testAction: string;
+}
+export declare function planHubInitOpening(input: {
+    loggedIn: boolean;
+    paseoDirectoryExists: boolean;
+}): HubInitOpeningPlan;
+export declare function createHubInitBundle(projectSlug: string, scaffold: HubInitScaffold): HubDeployBundle;
+export declare function resolveHubInitProjects(projects: readonly HubProject[]): HubInitProjectResolution;
+export declare function resolveHubInitConnection(status: HubStatus, origin: string): HubInitConnectionResolution;
+export declare function createHubInitScaffold(input: HubInitScaffoldInput): HubInitScaffold;
+//# sourceMappingURL=init-plan.d.ts.map

package/dist/commands/hub/init-plan.js

@@ -0,0 +1,136 @@
+import path from "node:path";
+import YAML from "yaml";
+export function planHubInitOpening(input) {
+    return {
+        replaceExisting: input.paseoDirectoryExists,
+        steps: [...(input.loggedIn ? [] : ["login"]), "connect", "project", "scaffold"],
+    };
+}
+export function createHubInitBundle(projectSlug, scaffold) {
+    return {
+        projectSlug,
+        workflowCount: 1,
+        files: [
+            { path: ".paseo/hub.yml", content: scaffold.hub },
+            { path: scaffold.workflowPath, content: scaffold.workflow },
+        ],
+    };
+}
+export function resolveHubInitProjects(projects) {
+    if (projects.length === 0)
+        return { kind: "none" };
+    if (projects.length === 1)
+        return { kind: "selected", project: projects[0] };
+    return { kind: "choose", projects };
+}
+export function resolveHubInitConnection(status, origin) {
+    if (status.state === "connected" && status.hubOrigin === origin && status.daemonId !== null) {
+        return { kind: "connected", daemonId: status.daemonId };
+    }
+    if ((status.state === "connecting" || status.state === "reconnecting") &&
+        status.hubOrigin === origin) {
+        return { kind: "pending", state: status.state };
+    }
+    if (status.hubOrigin !== null && status.state !== "not_connected" && status.state !== "revoked") {
+        return { kind: "conflict", origin: status.hubOrigin };
+    }
+    return { kind: "connect" };
+}
+export function createHubInitScaffold(input) {
+    const environmentName = input.daemonSlug;
+    const hub = YAML.stringify({
+        environments: {
+            [environmentName]: {
+                kind: "daemon",
+                daemon: input.daemonSlug,
+                cwd: path.resolve(input.cwd),
+            },
+        },
+        agents: {
+            codex: {
+                provider: "codex",
+                mode: "full-access",
+            },
+        },
+    }, { lineWidth: 0 });
+    const provider = providerScaffold(input.provider, input.providerFilters, environmentName);
+    return {
+        hub,
+        workflowPath: `.paseo/workflows/${input.provider}-help.yml`,
+        workflow: YAML.stringify(provider.workflow, { lineWidth: 0 }),
+        testAction: provider.testAction,
+    };
+}
+function providerScaffold(provider, filters, environment) {
+    if (provider === "github") {
+        const repo = requireFilter(filters, "repo");
+        const user = requireFilter(filters, "user");
+        return {
+            workflow: workflow({
+                name: "github-help",
+                on: "github.issue_comment",
+                filters: { repo, contains: "@paseo", from_users: [user] },
+                environment,
+            }),
+            testAction: `Comment \`@paseo have a look\` on ${repo}.`,
+        };
+    }
+    const user = requireFilter(filters, "user");
+    if (provider === "slack") {
+        const workspace = requireFilter(filters, "workspace");
+        return {
+            workflow: workflow({
+                name: "slack-help",
+                on: "slack.mention",
+                filters: { workspace, from_users: [user] },
+                environment,
+                reply: "slack.reply",
+            }),
+            testAction: "Mention `@Paseo have a look` in Slack.",
+        };
+    }
+    const guild = requireFilter(filters, "guild");
+    return {
+        workflow: workflow({
+            name: "discord-help",
+            on: "discord.mention",
+            filters: { guild, from_users: [user] },
+            environment,
+            reply: "discord.reply",
+        }),
+        testAction: "Mention `@Paseo have a look` in Discord.",
+    };
+}
+function workflow(input) {
+    const replyInstruction = input.reply === undefined ? "" : "Answer with hub.reply, then ";
+    return {
+        name: input.name,
+        on: input.on,
+        max_runtime: "2h",
+        filters: input.filters,
+        steps: [
+            {
+                id: "work",
+                environment: input.environment,
+                max_runtime: "90m",
+                idle_timeout: "10m",
+                agent: "codex",
+                prompt: [
+                    {
+                        text: `${replyInstruction}complete this request and call hub.finish_execution when done.\n\n<user-prompt>\n\${{ paseo.prompt }}\n</user-prompt>\n`,
+                    },
+                ],
+                ...(input.reply === undefined
+                    ? {}
+                    : { allow_outputs: [{ type: input.reply, max: 1, required: true }] }),
+            },
+        ],
+    };
+}
+function requireFilter(filters, name) {
+    const value = filters[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required for this provider`);
+    return value;
+}
+//# sourceMappingURL=init-plan.js.map

package/dist/commands/hub/init.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import type { HubHttpClient } from "./hub-client/index.js";
+import type { CliLoginFlow } from "./login-flow.js";
+import type { HubReporter } from "./reporter.js";
+interface HubInitEnvironment {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: HubHttpClient;
+    login: Pick<CliLoginFlow, "authorize">;
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+    cwd(): string;
+}
+export declare function addHubInitCommand(parent: Command, environment: HubInitEnvironment): void;
+export declare function runHubInit(environment: HubInitEnvironment): Promise<void>;
+export declare function githubRepositoryFromRemote(remote: string): string | undefined;
+export {};
+//# sourceMappingURL=init.d.ts.map