@vltpkg/cli-sdk 0.0.0-3 → 0.0.0-31

package/dist/esm/commands/whoami.d.ts

@@ -1,11 +1,13 @@
 import type { JSONField } from '@vltpkg/types';
 import type { CommandFn, CommandUsage } from '../index.ts';
-import type { Views } from '../view.ts';
 export declare const usage: CommandUsage;
 type CommandResult = {
     username?: JSONField;
 };
-export declare const views: Views<CommandResult>;
+export declare const views: {
+    readonly human: (r: CommandResult) => JSONField;
+    readonly json: (r: CommandResult) => CommandResult;
+};
 export declare const command: CommandFn<CommandResult>;
 export {};
 //# sourceMappingURL=whoami.d.ts.map

package/dist/esm/commands/whoami.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../../src/commands/whoami.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC,eAAO,MAAM,KAAK,EAAE,YAMhB,CAAA;AAEJ,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,aAAa,CAGtC,CAAA;AAED,eAAO,MAAM,OAAO,EAAE,SAAS,CAAC,aAAa,CAQ5C,CAAA"}
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../../src/commands/whoami.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1D,eAAO,MAAM,KAAK,EAAE,YAMhB,CAAA;AAEJ,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,KAAK;;;CAGuB,CAAA;AAEzC,eAAO,MAAM,OAAO,EAAE,SAAS,CAAC,aAAa,CAQ5C,CAAA"}

package/dist/esm/commands/whoami.js

@@ -12,7 +12,7 @@ export const views = {
 };
 export const command = async (conf) => {
     const rc = new RegistryClient(conf.options);
-    const response = await rc.request(new URL('-/whoami', conf.options.registry), { cache: false });
+    const response = await rc.request(new URL('-/whoami', conf.options.registry), { useCache: false });
     const { username } = response.json();
     return { username };
 };

package/dist/esm/commands/whoami.js.map

@@ -1 +1 @@
-{"version":3,"file":"whoami.js","sourceRoot":"","sources":["../../../src/commands/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAIjD,MAAM,CAAC,MAAM,KAAK,GAAiB,GAAG,EAAE,CACtC,YAAY,CAAC;IACX,OAAO,EAAE,QAAQ;IACjB,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,WAAW,EAAE;+CAC8B;CAC5C,CAAC,CAAA;AAMJ,MAAM,CAAC,MAAM,KAAK,GAAyB;IACzC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ;IACtB,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;CACb,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAA6B,KAAK,EAAC,IAAI,EAAC,EAAE;IAC5D,MAAM,EAAE,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC3C,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,OAAO,CAC/B,IAAI,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC1C,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAA;IACD,MAAM,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAA;IACpC,OAAO,EAAE,QAAQ,EAAE,CAAA;AACrB,CAAC,CAAA","sourcesContent":["import { RegistryClient } from '@vltpkg/registry-client'\nimport type { JSONField } from '@vltpkg/types'\nimport { commandUsage } from '../config/usage.ts'\nimport type { CommandFn, CommandUsage } from '../index.ts'\nimport type { Views } from '../view.ts'\n\nexport const usage: CommandUsage = () =>\n  commandUsage({\n    command: 'whoami',\n    usage: [''],\n    description: `Look up the username for the currently active token,\n                  when logged into a registry.`,\n  })\n\ntype CommandResult = {\n  username?: JSONField\n}\n\nexport const views: Views<CommandResult> = {\n  human: r => r.username,\n  json: r => r,\n}\n\nexport const command: CommandFn<CommandResult> = async conf => {\n  const rc = new RegistryClient(conf.options)\n  const response = await rc.request(\n    new URL('-/whoami', conf.options.registry),\n    { cache: false },\n  )\n  const { username } = response.json()\n  return { username }\n}\n"]}
+{"version":3,"file":"whoami.js","sourceRoot":"","sources":["../../../src/commands/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAIjD,MAAM,CAAC,MAAM,KAAK,GAAiB,GAAG,EAAE,CACtC,YAAY,CAAC;IACX,OAAO,EAAE,QAAQ;IACjB,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,WAAW,EAAE;+CAC8B;CAC5C,CAAC,CAAA;AAMJ,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ;IACtB,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;CAC2B,CAAA;AAEzC,MAAM,CAAC,MAAM,OAAO,GAA6B,KAAK,EAAC,IAAI,EAAC,EAAE;IAC5D,MAAM,EAAE,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC3C,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,OAAO,CAC/B,IAAI,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC1C,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAA;IACD,MAAM,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAA;IACpC,OAAO,EAAE,QAAQ,EAAE,CAAA;AACrB,CAAC,CAAA","sourcesContent":["import { RegistryClient } from '@vltpkg/registry-client'\nimport type { JSONField } from '@vltpkg/types'\nimport { commandUsage } from '../config/usage.ts'\nimport type { CommandFn, CommandUsage } from '../index.ts'\nimport type { Views } from '../view.ts'\n\nexport const usage: CommandUsage = () =>\n  commandUsage({\n    command: 'whoami',\n    usage: [''],\n    description: `Look up the username for the currently active token,\n                  when logged into a registry.`,\n  })\n\ntype CommandResult = {\n  username?: JSONField\n}\n\nexport const views = {\n  human: r => r.username,\n  json: r => r,\n} as const satisfies Views<CommandResult>\n\nexport const command: CommandFn<CommandResult> = async conf => {\n  const rc = new RegistryClient(conf.options)\n  const response = await rc.request(\n    new URL('-/whoami', conf.options.registry),\n    { useCache: false },\n  )\n  const { username } = response.json()\n  return { username }\n}\n"]}

package/dist/esm/config/definition.d.ts

@@ -1,4 +1,5 @@
 export declare const defaultView: string;
+export declare const defaultEditor: () => string;
 /**
  * Command aliases mapped to their canonical names
  */
@@ -11,27 +12,35 @@ export declare const commands: {
     readonly 'run-script': "run";
     readonly rx: "run-exec";
     readonly x: "exec";
+    readonly xl: "exec-local";
     readonly h: "help";
     readonly '?': "help";
-    readonly conf: "config";
-    readonly ix: "install-exec";
     readonly ls: "list";
+    readonly xc: "exec-cache";
+    readonly build: "build";
+    readonly cache: "cache";
+    readonly ci: "ci";
     readonly config: "config";
     readonly exec: "exec";
-    readonly gui: "gui";
+    readonly 'exec-local': "exec-local";
     readonly help: "help";
     readonly init: "init";
-    readonly 'install-exec': "install-exec";
     readonly install: "install";
     readonly login: "login";
     readonly logout: "logout";
     readonly list: "list";
+    readonly pack: "pack";
     readonly pkg: "pkg";
+    readonly publish: "publish";
     readonly query: "query";
     readonly 'run-exec': "run-exec";
     readonly run: "run";
+    readonly serve: "serve";
     readonly token: "token";
     readonly uninstall: "uninstall";
+    readonly update: "update";
+    readonly 'exec-cache': "exec-cache";
+    readonly version: "version";
     readonly whoami: "whoami";
 };
 /**
@@ -43,7 +52,7 @@ export declare const getCommand: (s?: string) => Commands[keyof Commands] | unde
 /**
  * Fields that are parsed as a set of key=value pairs
  */
-export declare const recordFields: readonly ["git-hosts", "registries", "git-host-archives", "scope-registries"];
+export declare const recordFields: readonly ["git-hosts", "registries", "git-host-archives", "scope-registries", "jsr-registries"];
 export type RecordField = (typeof recordFields)[number];
 export declare const isRecordField: (s: string) => s is RecordField;
 export declare const definition: import("jackspeak").Jack<{
@@ -75,6 +84,10 @@ export declare const definition: import("jackspeak").Jack<{
         hint: string;
         description: string;
     };
+    'jsr-registries': {
+        hint: string;
+        description: string;
+    };
     'git-hosts': {
         hint: string;
         short: string;
@@ -88,6 +101,7 @@ export declare const definition: import("jackspeak").Jack<{
 } & {
     registries: import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
     'scope-registries': import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
+    'jsr-registries': import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
     'git-hosts': import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
     'git-host-archives': import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
 } & {
@@ -151,11 +165,17 @@ export declare const definition: import("jackspeak").Jack<{
         description: string;
         default: number;
     };
+    'stale-while-revalidate-factor': {
+        hint: string;
+        default: number;
+        description: string;
+    };
 } & {
     'fetch-retries': import("jackspeak").ConfigOption<"number", false, readonly number[] | undefined>;
     'fetch-retry-factor': import("jackspeak").ConfigOption<"number", false, readonly number[] | undefined>;
     'fetch-retry-mintimeout': import("jackspeak").ConfigOption<"number", false, readonly number[] | undefined>;
     'fetch-retry-maxtimeout': import("jackspeak").ConfigOption<"number", false, readonly number[] | undefined>;
+    'stale-while-revalidate-factor': import("jackspeak").ConfigOption<"number", false, readonly number[] | undefined>;
 } & {
     identity: {
         short: string;
@@ -179,6 +199,26 @@ export declare const definition: import("jackspeak").Jack<{
 } & {
     workspace: import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
     'workspace-group': import("jackspeak").ConfigOption<"string", true, readonly string[] | undefined>;
+} & {
+    scope: {
+        short: string;
+        hint: string;
+        description: string;
+    };
+    target: {
+        short: string;
+        hint: string;
+        description: string;
+    };
+} & {
+    scope: import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+    target: import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+} & {
+    'if-present': {
+        description: string;
+    };
+} & {
+    'if-present': import("jackspeak").ConfigOption<"boolean", false, undefined>;
 } & {
     recursive: {
         short: string;
@@ -201,7 +241,7 @@ export declare const definition: import("jackspeak").Jack<{
     config: {
         hint: string;
         description: string;
-        validOptions: readonly ["user", "project"];
+        validOptions: readonly ["all", "user", "project"];
         default: string;
     };
     editor: {
@@ -236,7 +276,7 @@ export declare const definition: import("jackspeak").Jack<{
         hint: string;
         default: string;
         description: string;
-        validOptions: readonly ["human", "json", "mermaid", "gui", "inspect"];
+        validOptions: readonly ["human", "json", "mermaid", "gui", "inspect", "silent"];
     };
 } & {
     view: import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
@@ -269,18 +309,85 @@ export declare const definition: import("jackspeak").Jack<{
     'save-peer': import("jackspeak").ConfigOption<"boolean", false, undefined>;
     'save-prod': import("jackspeak").ConfigOption<"boolean", false, undefined>;
 } & {
-    version: {
-        short: string;
+    'expect-results': {
+        hint: string;
+        validate: (v: unknown) => boolean;
         description: string;
     };
 } & {
-    version: import("jackspeak").ConfigOption<"boolean", false, undefined>;
+    'expect-results': import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
 } & {
+    'dry-run': {
+        description: string;
+    };
+    'expect-lockfile': {
+        description: string;
+    };
+    'frozen-lockfile': {
+        description: string;
+    };
+    'lockfile-only': {
+        description: string;
+    };
+} & {
+    'dry-run': import("jackspeak").ConfigOption<"boolean", false, undefined>;
+    'expect-lockfile': import("jackspeak").ConfigOption<"boolean", false, undefined>;
+    'frozen-lockfile': import("jackspeak").ConfigOption<"boolean", false, undefined>;
+    'lockfile-only': import("jackspeak").ConfigOption<"boolean", false, undefined>;
+} & {
+    'allow-scripts': {
+        hint: string;
+        description: string;
+    };
+} & {
+    'allow-scripts': import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+} & {
+    access: {
+        description: string;
+        validOptions: readonly ["public", "restricted"];
+        default: string;
+    };
+} & {
+    access: import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+} & {
+    otp: {
+        description: string;
+    };
+    'publish-directory': {
+        hint: string;
+        description: string;
+    };
+    port: {
+        hint: string;
+        description: string;
+    };
+    'registry-port': {
+        hint: string;
+        description: string;
+    };
+} & {
+    otp: import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+    'publish-directory': import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+    port: import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+    'registry-port': import("jackspeak").ConfigOption<"string", false, readonly string[] | undefined>;
+} & {
+    yes: {
+        short: string;
+        description: string;
+    };
+    version: {
+        short: string;
+        description: string;
+    };
     help: {
         short: string;
         description: string;
     };
 } & {
+    yes: import("jackspeak").ConfigOption<"boolean", false, undefined>;
+    version: import("jackspeak").ConfigOption<"boolean", false, undefined>;
     help: import("jackspeak").ConfigOption<"boolean", false, undefined>;
 }>;
+export declare const getSortedCliOptions: () => string[];
+export declare const getSortedKeys: () => string[];
 //# sourceMappingURL=definition.d.ts.map

package/dist/esm/config/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/config/definition.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,QAA0C,CAAA;AAuClE;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGX,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,cAAc,uBAW1B,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAA;AAEtC,eAAO,MAAM,UAAU,OACjB,MAAM,KACT,QAAQ,CAAC,MAAM,QAAQ,CAAC,GAAG,SACkC,CAAA;AAKhE;;GAEG;AACH,eAAO,MAAM,YAAY,+EAKf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,aAAa,MAAO,MAAM,KAAG,CAAC,IAAI,WACN,CAAA;AAwCzC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAqMH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyMvB,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/config/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,QAOd,CAAA;AAEV,eAAO,MAAM,aAAa,cAKjB,CAAA;AA+CT;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGX,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,cAAc,uBAW1B,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAA;AAEtC,eAAO,MAAM,UAAU,OACjB,MAAM,KACT,QAAQ,CAAC,MAAM,QAAQ,CAAC,GAAG,SACkC,CAAA;AAKhE;;GAEG;AACH,eAAO,MAAM,YAAY,iGAMf,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,aAAa,MAAO,MAAM,KAAG,CAAC,IAAI,WACN,CAAA;AAwCzC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA2OH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmOP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkFvB,CAAA;AAEJ,eAAO,MAAM,mBAAmB,gBAS/B,CAAA;AAED,eAAO,MAAM,aAAa,gBAC2C,CAAA"}

package/dist/esm/config/definition.js

@@ -1,24 +1,45 @@
+import { error } from '@vltpkg/error-cause';
 import { XDG } from '@vltpkg/xdg';
 import { jack } from 'jackspeak';
-export const defaultView = process.stdout.isTTY ? 'human' : 'json';
+export const defaultView = 
+// If stdout is a TTY, use human output
+process.stdout.isTTY ? 'human'
+    // If its not a TTY but is a CI environment, use human output
+    // TODO: make a better view option for CI environments
+    : process.env.CI ? 'human'
+        // Otherwise, use json output
+        : 'json';
+export const defaultEditor = () => process.env.EDITOR ||
+    process.env.VISUAL ||
+    (process.platform === 'win32' ?
+        `${process.env.SYSTEMROOT}\\notepad.exe`
+        : 'vi');
 const canonicalCommands = {
+    build: 'build',
+    cache: 'cache',
+    ci: 'ci',
     config: 'config',
     exec: 'exec',
-    gui: 'gui',
+    'exec-local': 'exec-local',
     help: 'help',
     init: 'init',
-    'install-exec': 'install-exec',
     install: 'install',
     login: 'login',
     logout: 'logout',
     list: 'list',
     ls: 'ls',
+    pack: 'pack',
     pkg: 'pkg',
+    publish: 'publish',
     query: 'query',
     'run-exec': 'run-exec',
     run: 'run',
+    serve: 'serve',
     token: 'token',
     uninstall: 'uninstall',
+    update: 'update',
+    'exec-cache': 'exec-cache',
+    version: 'version',
     whoami: 'whoami',
 };
 const aliases = {
@@ -30,11 +51,11 @@ const aliases = {
     'run-script': 'run',
     rx: 'run-exec',
     x: 'exec',
+    xl: 'exec-local',
     h: 'help',
     '?': 'help',
-    conf: 'config',
-    ix: 'install-exec',
     ls: 'list',
+    xc: 'exec-cache',
 };
 /**
  * Command aliases mapped to their canonical names
@@ -67,13 +88,14 @@ export const recordFields = [
     'registries',
     'git-host-archives',
     'scope-registries',
+    'jsr-registries',
 ];
 export const isRecordField = (s) => recordFields.includes(s);
 const stopParsingCommands = [
     'run',
     'run-exec',
+    'exec-local',
     'exec',
-    'install-exec',
 ];
 let stopParsing = undefined;
 const j = jack({
@@ -188,6 +210,24 @@ export const definition = j
                     However, custom registry aliases are not supported by other
                     package managers.`,
     },
+    'jsr-registries': {
+        hint: 'name=url',
+        description: `Map alias names to JSR.io registry urls.
+
+                    For example,
+                    \`--jsr-registries acme=https://jsr.acme.io/\` would
+                    tell vlt to fetch any packages with the \`acme:\` registry
+                    prefix from the \`https://jsr.acme.io/\` registry, using
+                    the "npm Compatibility" translation. So for example,
+                    the package \`acme:@foo/bar\` would fetch the
+                    \`@jsr/foo__bar\` package from the \`jsr.acme.io\`
+                    registry.
+
+                    By default the \`jsr\` alias is always mapped to
+                    \`https://npm.jsr.io/\`, so existing \`jsr:\` packages will
+                    be fetched from the public \`jsr\` registry appropriately.
+                   `,
+    },
     'git-hosts': {
         hint: `name=template`,
         short: 'G',
@@ -225,7 +265,7 @@ export const definition = j
         default: cacheDir,
     },
     tag: {
-        description: `Default \`dist-tag\` to install`,
+        description: `Default \`dist-tag\` to install or publish`,
         default: 'latest',
     },
     before: {
@@ -282,6 +322,25 @@ export const definition = j
         description: `Maximum number of milliseconds between two retries`,
         default: 30_000,
     },
+    'stale-while-revalidate-factor': {
+        hint: 'n',
+        default: 60,
+        description: `If the server does not serve a \`stale-while-revalidate\`
+                    value in the \`cache-control\` header, then this multiplier
+                    is applied to the \`max-age\` or \`s-maxage\` values.
+
+                    By default, this is \`60\`, so for example a response that
+                    is cacheable for 5 minutes will allow a stale response
+                    while revalidating for up to 5 hours.
+
+                    If the server *does* provide a \`stale-while-revalidate\`
+                    value, then that is always used.
+
+                    Set to 0 to prevent any \`stale-while-revalidate\` behavior
+                    unless explicitly allowed by the server's \`cache-control\`
+                    header.
+      `,
+    },
 })
     .opt({
     identity: {
@@ -319,6 +378,31 @@ export const definition = j
         description: `Specify named workspace group names to load and operate on
                     when doing recursive operations on workspaces.`,
     },
+})
+    .opt({
+    scope: {
+        short: 's',
+        hint: 'query',
+        description: 'Set to filter the scope of an operation using a DSS Query.',
+    },
+    target: {
+        short: 't',
+        hint: 'query',
+        description: 'Set to select packages using a DSS Query selector.',
+    },
+})
+    .flag({
+    'if-present': {
+        description: `When running scripts across multiple packages,
+                    only include packages that have the script.
+
+                    If this is not set, then the run will fail if any
+                    packages do not have the script.
+
+                    This will default to true if --scope, --workspace,
+                    --workspace-group, or --recursive is set. Otherwise,
+                    it will default to false.`,
+    },
 })
     .flag({
     recursive: {
@@ -344,11 +428,16 @@ export const definition = j
 })
     .opt({
     config: {
-        hint: 'user | project',
-        description: `Specify whether to operate on user-level or project-level
-                    configuration files when running \`vlt config\` commands.`,
-        validOptions: ['user', 'project'],
-        default: 'project',
+        hint: 'all | user | project',
+        description: `Specify which configuration to show or operate on when running
+                    \`vlt config\` commands. For read operations (get, pick, list):
+                    \`all\` shows merged configuration from both user and project
+                    files (default). For write operations (set, delete, edit):
+                    defaults to \`project\`. \`user\` shows/modifies only user-level
+                    configuration, \`project\` shows/modifies only project-level
+                    configuration.`,
+        validOptions: ['all', 'user', 'project'],
+        default: 'all',
     },
     editor: {
         hint: 'program',
@@ -358,23 +447,23 @@ export const definition = j
 
                     Defaults to the \`EDITOR\` or \`VISUAL\` env if set, or
                     \`notepad.exe\` on Windows, or \`vi\` elsewhere.`,
-        default: process.env.EDITOR ||
-            process.env.VISUAL ||
-            (process.platform === 'win32' ?
-                `${process.env.SYSTEMROOT}\\notepad.exe`
-                : 'vi'),
+        default: defaultEditor(),
     },
     'script-shell': {
         hint: 'program',
-        description: `The shell to use when executing \`package.json#scripts\`
-                    (either as lifecycle scripts or explicitly with
-                    \`vlt run\`) and \`vlt exec\`.
+        description: `The shell to use when executing \`package.json#scripts\`.
 
-                    If not set, defaults to \`/bin/sh\` on POSIX systems,
-                    and \`cmd.exe\` on Windows.
+                    For \`vlt exec\` and \`vlt exec-local\`, this is never set,
+                    meaning that command arguments are run exactly as provided.
 
-                    When no argument is provided to \`vlt exec\`, the \`SHELL\`
-                    environment variable takes precedence if set.`,
+                    For \`vlt run\` (and other things that run lifecycle
+                    scripts in \`package.json#scripts\`), the entire command
+                    with all arguments is provided as a single string, meaning
+                    that some value must be provided for shell interpretation,
+                    and so for these contexts, the \`script-shell\` value will
+                    default to \`/bin/sh\` on POSIX systems or \`cmd.exe\` on
+                    Windows.
+      `,
     },
     'fallback-command': {
         hint: 'command',
@@ -392,10 +481,10 @@ export const definition = j
     .opt({
     package: {
         hint: 'p',
-        description: `When running \`vlt install-exec\`, this allows you to
-                    explicitly set the package to search for bins. If not
-                    provided, then vlt will interpret the first argument as
-                    the package, and attempt to run the default executable.`,
+        description: `When running \`vlt exec\`, this allows you to explicitly
+                    set the package to search for bins. If not provided, then
+                    vlt will interpret the first argument as the package, and
+                    attempt to run the default executable.`,
     },
 })
     .opt({
@@ -416,6 +505,7 @@ export const definition = j
                       commands.)
                     - mermaid: Output mermaid diagramming syntax. (Only
                       relevant for certain commands.)
+                    - silent: Suppress all output to stdout.
 
                     If the requested view format is not supported for the
                     current command, or if no option is provided, then it
@@ -427,13 +517,14 @@ export const definition = j
             'mermaid',
             'gui',
             'inspect',
+            'silent',
         ],
     },
 })
     .optList({
     'dashboard-root': {
         hint: 'path',
-        description: `The root directory to use for the dashboard GUI.
+        description: `The root directory to use for the dashboard browser-based UI.
                     If not set, the user home directory is used.`,
     },
 })
@@ -459,17 +550,98 @@ export const definition = j
                     devDependencies or optionalDependencies, but you want to
                     move it to be a non-optional production dependency.`,
     },
+})
+    .opt({
+    'expect-results': {
+        hint: 'value',
+        validate: (v) => typeof v === 'string' && /^([<>]=?)?[0-9]+$/.test(v),
+        description: `When running \`vlt query\`, this option allows you to
+                    set a expected number of resulting items.
+
+                    Accepted values are numbers and strings.
+
+                    Strings starting with \`>\`, \`<\`, \`>=\` or \`<=\`
+                    followed by a number can be used to check if the result
+                    is greater than or less than a specific number.`,
+    },
 })
     .flag({
+    'dry-run': {
+        description: 'Run command without making any changes',
+    },
+    'expect-lockfile': {
+        description: 'Fail if lockfile is missing or out of date. Used by ci command to enforce lockfile integrity.',
+    },
+    'frozen-lockfile': {
+        description: 'Fail if lockfile is missing or out of sync with package.json. Prevents any lockfile modifications.',
+    },
+    'lockfile-only': {
+        description: 'Only update the lockfile (vlt-lock.json) and package.json files, skip all node_modules operations including package extraction and filesystem changes.',
+    },
+})
+    .opt({
+    'allow-scripts': {
+        hint: 'query',
+        description: `Filter which packages are allowed to run lifecycle scripts using DSS query syntax.
+                    When provided, only packages matching the query will execute their
+                    install, preinstall, postinstall, prepare, preprepare, and postprepare scripts.
+                    Defaults to ':not(*)' which means no scripts will be run.
+                    
+                    Example: --allow-scripts=":root > *, #my-package"
+                    Runs scripts only for direct dependencies of the current project and any occurrences
+                    of a specific dependency with the name "my-package" anywhere in the dependency graph.`,
+    },
+})
+    .opt({
+    access: {
+        description: 'Set the access level of the package',
+        validOptions: ['public', 'restricted'],
+        default: 'public',
+    },
+})
+    .opt({
+    otp: {
+        description: `Provide an OTP to use when publishing a package.`,
+    },
+    'publish-directory': {
+        hint: 'path',
+        description: `Directory to use for pack and publish operations instead of the current directory.
+                    The directory must exist and nothing will be copied to it.`,
+    },
+    port: {
+        hint: 'number',
+        description: `Port for the browser-based UI server when using vlt serve command (default: 8000).`,
+    },
+    'registry-port': {
+        hint: 'number',
+        description: `Port for the VSR registry when using vlt serve command (default: 1337).`,
+    },
+})
+    .flag({
+    yes: {
+        short: 'y',
+        description: `Automatically accept any confirmation prompts`,
+    },
     version: {
         short: 'v',
         description: 'Print the version',
     },
-})
-    .flag({
     help: {
         short: 'h',
         description: 'Print helpful information',
     },
 });
+export const getSortedCliOptions = () => {
+    const defs = definition.toJSON();
+    return getSortedKeys().map((k) => {
+        const def = defs[k];
+        /* c8 ignore next */
+        if (!def)
+            throw error('invalid key found', { found: k });
+        if (def.type === 'boolean')
+            return `--${k}`;
+        return `--${k}=<${def.hint ?? k}>`;
+    });
+};
+export const getSortedKeys = () => Object.keys(definition.toJSON()).sort((a, b) => a.localeCompare(b));
 //# sourceMappingURL=definition.js.map