deepline 0.3.463 → 0.3.464

package/dist/bundling-sources/shared_libs/plays/field-catalog.ts

@@ -4,22 +4,30 @@ import type { DeeplineExtractorTarget } from './extractor-targets';
  * The catalog of things a tool or play can take or return about a person or
  * a company, named by what they are instead of by what a provider calls them.
  *
- * An id is a dotted path that always ends in a leaf:
+ * An id is a dotted path that always ends in `.value`:
  *
  *   person.email.value            any email for the person
  *   person.email.work.value       their work email
- *   person.email.work.validated   whether that work email was validated
+ *   person.email.work.validated.value   whether it was validated
  *
- * It reads `<entity>.<group>[.<kind>].<leaf>`. A group is one thing about the
- * entity (an email). A leaf is one fact about that thing (its value, whether
- * it was validated). A kind narrows which one is meant (work, personal). No
- * id is both a field and a parent of fields, so `person.email` alone is never
- * a field; the plain value is `person.email.value`.
+ * It reads `<entity>.<group>[.<group>][.<kind>][.<leaf>].value`. A group is one thing
+ * about the entity (an email), and may hold groups of its own (a job's
+ * title). A leaf is one fact about that thing (its value, whether it was
+ * validated). A kind narrows which one is meant (work, personal). No id is
+ * both a field and a parent of fields, so `person.email` alone is never a
+ * field; the plain value is `person.email.value`.
  *
- * A kind is a narrowing, so a field with a kind also answers for the same
- * field without it: a tool that returns `person.email.work.value` satisfies a
- * request for `person.email.value`. A tool that cannot tell which kind it has
- * declares the id without one.
+ * A narrower field answers for every more general one:
+ *
+ *   person.email.work.value   answers person.email.value (its kind dropped)
+ *   person.email.value        answers entity.email.value (a person or company)
+ *
+ * A tool that cannot tell which kind it has declares the id without one; a
+ * tool whose record may be a person or a company declares the `entity` id.
+ *
+ * `provider.<provider>.<...>.value` names a value that belongs to one
+ * provider and is not about a person or company (a HubSpot list's name). It
+ * is declared where the provider's tool is, and answers only for itself.
  *
  * This is an addition. Existing short names (`email`, `name`) keep working;
  * `EXTRACTOR_TARGET_FIELDS` records what each can mean.
@@ -28,9 +36,11 @@ type Leaf = { type: string; description: string };
 
 type Group = {
   description: string;
-  leaves: Record<string, Leaf>;
+  leaves?: Record<string, Leaf>;
   /** Narrowings of this group. Each has every leaf the group has. */
   kinds?: Record<string, string>;
+  /** Things within this one, each a group of its own. */
+  groups?: Record<string, Group>;
 };
 
 const value = (description: string): Leaf => ({ type: 'string', description });
@@ -43,11 +53,12 @@ const SOURCE: Leaf = {
 export const FIELD_CATALOG = {
   person: {
     name: {
-      description: "The person's name.",
-      leaves: {
-        value: value('Full name.'),
-        first: value('First (given) name.'),
-        last: value('Last (family) name.'),
+      description: "The person's name. Without a kind, a name in some form.",
+      leaves: { value: value('The name.') },
+      kinds: {
+        full: 'Their full name.',
+        first: 'Their first (given) name.',
+        last: 'Their last (family) name.',
       },
     },
     email: {
@@ -92,12 +103,25 @@ export const FIELD_CATALOG = {
     },
     linkedin: {
       description: "The person's LinkedIn profile.",
-      leaves: { url: value('The profile URL.') },
+      leaves: {
+        url: value('The profile URL.'),
+        id: value("LinkedIn's id or public identifier for the profile."),
+      },
     },
     job: {
       description: "The person's current role.",
+      groups: {
+        title: {
+          description:
+            'What their role is called. Without a kind, a job title or, failing one, their profile headline.',
+          leaves: { value: value('The title.') },
+          kinds: {
+            exact: 'Their job title, never a headline.',
+            headline: 'Their profile headline, used as a title.',
+          },
+        },
+      },
       leaves: {
-        title: value('Job title.'),
         change: {
           type: 'JobChange',
           description: 'Whether they changed jobs, and to what.',
@@ -144,6 +168,72 @@ export const FIELD_CATALOG = {
       leaves: { id: value("The provider's id for the company.") },
     },
   },
+  job: {
+    posting: {
+      description: 'A job posting.',
+      groups: {
+        title: {
+          description: "The posting's title. Not a person's job title.",
+          leaves: { value: value('The title.') },
+        },
+      },
+    },
+  },
+  podcast: {
+    name: {
+      description: "A podcast's name.",
+      leaves: { value: value('The name.') },
+    },
+    website: {
+      description: "A podcast's own page.",
+      leaves: { url: value('The URL.') },
+    },
+  },
+  post: {
+    title: {
+      description: "A social or business post's title.",
+      leaves: { value: value('The title.') },
+    },
+    author: {
+      description: "A post's author, who may be a person or a company.",
+      groups: {
+        name: {
+          description: "The author's name.",
+          leaves: { value: value('The name.') },
+        },
+      },
+    },
+  },
+  page: {
+    title: {
+      description: "A web page's title.",
+      leaves: { value: value('The title.') },
+    },
+  },
+  // Some entity's value, when a tool cannot say whether it is a person's or a
+  // company's. Each field here is answered by the same field of either.
+  entity: {
+    name: {
+      description: "A person's or company's name.",
+      leaves: { value: value('The name.') },
+    },
+    email: {
+      description: 'An email address for a person or company.',
+      leaves: { value: value('The address.') },
+    },
+    phone: {
+      description: 'A phone number for a person or company.',
+      leaves: { value: value('The number.') },
+    },
+    linkedin: {
+      description: "A person's or company's LinkedIn page.",
+      leaves: { url: value('The page URL.') },
+    },
+    record: {
+      description: "A provider's own record of a person or company.",
+      leaves: { id: value("The provider's id for the record.") },
+    },
+  },
 } as const satisfies Record<string, Record<string, Group>>;
 
 export type FieldEntity = keyof typeof FIELD_CATALOG;
@@ -151,25 +241,51 @@ export type FieldEntity = keyof typeof FIELD_CATALOG;
 export type CatalogField = Leaf & {
   id: string;
   entity: FieldEntity;
+  /** The group's path within the entity, such as `email` or `job.title`. */
   group: string;
   kind?: string;
   leaf: string;
 };
 
+// Every id ends in `.value`, so `.values` reads the same way on every field.
+function fieldId(
+  entity: string,
+  group: string,
+  kind: string | undefined,
+  leaf: string,
+): string {
+  return [entity, group, kind, leaf === 'value' ? undefined : leaf, 'value']
+    .filter(Boolean)
+    .join('.');
+}
+
+function groupFields(
+  entity: FieldEntity,
+  group: string,
+  definition: Group,
+): CatalogField[] {
+  const own = [undefined, ...Object.keys(definition.kinds ?? {})].flatMap(
+    (kind) =>
+      Object.entries(definition.leaves ?? {}).map(([leaf, described]) => ({
+        ...described,
+        id: fieldId(entity, group, kind, leaf),
+        entity,
+        group,
+        ...(kind ? { kind } : {}),
+        leaf,
+      })),
+  );
+  const nested = Object.entries(definition.groups ?? {}).flatMap(
+    ([name, child]) => groupFields(entity, `${group}.${name}`, child),
+  );
+  return [...own, ...nested];
+}
+
 /** Every field in the catalog, with and without each kind. */
 export function catalogFields(): CatalogField[] {
   return Object.entries(FIELD_CATALOG).flatMap(([entity, groups]) =>
     Object.entries<Group>(groups).flatMap(([group, definition]) =>
-      [undefined, ...Object.keys(definition.kinds ?? {})].flatMap((kind) =>
-        Object.entries(definition.leaves).map(([leaf, described]) => ({
-          ...described,
-          id: [entity, group, kind, leaf].filter(Boolean).join('.'),
-          entity: entity as FieldEntity,
-          group,
-          ...(kind ? { kind } : {}),
-          leaf,
-        })),
-      ),
+      groupFields(entity as FieldEntity, group, definition),
     ),
   );
 }
@@ -180,15 +296,45 @@ export function catalogField(id: string): CatalogField | undefined {
   return FIELDS_BY_ID.get(id);
 }
 
+const PROVIDER_FIELD = /^provider\.[a-z0-9_-]+(\.[a-z0-9_]+)+\.value$/;
+
+/**
+ * Whether `id` names a field: one in the catalog, or a provider's own
+ * (`provider.hubspot.list.name.value`).
+ */
+export function isFieldId(id: string): boolean {
+  return FIELDS_BY_ID.has(id) || PROVIDER_FIELD.test(id);
+}
+
 /** The same field without its kind, or null when it has none to drop. */
 export function generalField(id: string): string | null {
   const field = FIELDS_BY_ID.get(id);
-  return field?.kind ? [field.entity, field.group, field.leaf].join('.') : null;
+  return field?.kind
+    ? fieldId(field.entity, field.group, undefined, field.leaf)
+    : null;
+}
+
+/**
+ * Every more general field this one answers for: without its kind, and as
+ * the `entity` field when there is one.
+ */
+export function generalFields(id: string): string[] {
+  const field = FIELDS_BY_ID.get(id);
+  if (!field) return [];
+  const general = generalField(id);
+  const entity = fieldId('entity', field.group, undefined, field.leaf);
+  return [
+    ...(general ? [general] : []),
+    ...((field.entity === 'person' || field.entity === 'company') &&
+    FIELDS_BY_ID.has(entity)
+      ? [entity]
+      : []),
+  ];
 }
 
 /** Whether a tool returning `offered` gives a caller what `wanted` asks for. */
 export function fieldSatisfies(offered: string, wanted: string): boolean {
-  return offered === wanted || generalField(offered) === wanted;
+  return offered === wanted || generalFields(offered).includes(wanted);
 }
 
 /**
@@ -204,50 +350,205 @@ export const EXTRACTOR_TARGET_FIELDS: Record<
 > = {
   email: ['person.email.value'],
   personal_email: ['person.email.personal.value'],
-  email_status: ['person.email.status'],
+  email_status: ['person.email.status.value'],
   phone: ['person.phone.value', 'company.phone.value'],
-  phone_status: ['person.phone.status'],
-  first_name: ['person.name.first'],
-  last_name: ['person.name.last'],
-  full_name: ['person.name.value'],
+  phone_status: ['person.phone.status.value'],
+  first_name: ['person.name.first.value'],
+  last_name: ['person.name.last.value'],
+  full_name: ['person.name.full.value'],
   // Also used for a list name, a channel title and a search suggestion.
   name: ['person.name.value', 'company.name.value'],
-  linkedin: ['person.linkedin.url', 'company.linkedin.url'],
-  linkedin_url: ['person.linkedin.url'],
-  title: ['person.job.title'],
-  job_change: ['person.job.change'],
-  job_change_status: ['person.job.change_status'],
+  linkedin: [
+    'person.linkedin.url.value',
+    'person.linkedin.id.value',
+    'company.linkedin.url.value',
+  ],
+  linkedin_url: ['person.linkedin.url.value'],
+  title: ['person.job.title.value'],
+  job_change: ['person.job.change.value'],
+  job_change_status: ['person.job.change_status.value'],
   company: ['company.name.value'],
   company_name: ['company.name.value'],
   organization_name: ['company.name.value'],
   company_domain: ['company.domain.value'],
   domain: ['company.domain.value'],
-  company_website: ['company.website.url'],
+  company_website: ['company.website.url.value'],
   // Also used for a podcast URL.
-  website: ['company.website.url'],
-  company_linkedin_url: ['company.linkedin.url'],
+  website: ['company.website.url.value'],
+  company_linkedin_url: ['company.linkedin.url.value'],
   industry: ['company.industry.value'],
-  id: ['person.record.id', 'company.record.id'],
+  id: ['person.record.id.value', 'company.record.id.value'],
   // Used for unrelated provider statuses; none is a catalog field.
   status: [],
 };
 
 /**
- * The catalog field a short name stands for on one tool: what the tool
- * declares, or else the name's one meaning. Undefined when the name is
- * ambiguous and the tool has not said, or when what it said is not something
- * the name can mean.
+ * The field a short name stands for on one tool: what the tool declares, or
+ * else the name's one meaning. Undefined when the name is ambiguous and the
+ * tool has not said, or when what it said is not something the name can mean.
+ * Any name may be declared as a provider's own field, or as a field of a
+ * thing that is neither a person nor a company.
  */
 export function fieldOfName(
   name: string,
   declared?: string,
 ): string | undefined {
-  const meanings: readonly string[] =
-    EXTRACTOR_TARGET_FIELDS[name as DeeplineExtractorTarget] ?? [];
+  const meanings = nameMeanings(name);
   if (declared === undefined) {
     return meanings.length === 1 ? meanings[0] : undefined;
   }
-  return meanings.some((meaning) => fieldSatisfies(declared, meaning))
+  return isOtherThing(declared) ||
+    meanings.some((meaning) => relatedFields(declared, meaning))
     ? declared
     : undefined;
 }
+
+function nameMeanings(name: string): readonly string[] {
+  return EXTRACTOR_TARGET_FIELDS[name as DeeplineExtractorTarget] ?? [];
+}
+
+// A narrowing of a meaning (`email` as a work email), or a generalization of
+// one (`name` as `entity.name.value` when the record may be either).
+function relatedFields(a: string, b: string): boolean {
+  return fieldSatisfies(a, b) || fieldSatisfies(b, a);
+}
+
+/**
+ * A provider's own field, or a thing that is neither a person nor a company.
+ * Any output may be declared as one, whatever its name.
+ */
+function isOtherThing(id: string): boolean {
+  if (PROVIDER_FIELD.test(id)) return true;
+  const entity = FIELDS_BY_ID.get(id)?.entity;
+  return (
+    entity !== undefined &&
+    entity !== 'person' &&
+    entity !== 'company' &&
+    entity !== 'entity'
+  );
+}
+
+/** One output of a tool, and the catalog field it is. */
+export type FieldBinding = { name: string; id: string };
+
+/**
+ * The one output a name stands for, among a result's bindings. A name is
+ * tried as an exact id, then as a more general id that exactly one declared
+ * field narrows, then as the output's own name, then as a short name the
+ * catalog knows. The first step with a single field wins. Two or more at a
+ * step is an error listing them: this never picks between candidates.
+ * Undefined when nothing matches, or when `name` is one of the target's
+ * `outputs` that is not a field: a tool's own name means its own output.
+ */
+export function resolveFieldName(
+  name: string,
+  bindings: readonly FieldBinding[],
+  outputs: readonly string[] = [],
+): FieldBinding | undefined {
+  // Two outputs declared as the same field are the same field.
+  const byId = new Map<string, FieldBinding>();
+  for (const binding of bindings) {
+    if (!byId.has(binding.id)) byId.set(binding.id, binding);
+  }
+  const fields = [...byId.values()];
+  const pick = (matches: FieldBinding[]): FieldBinding | undefined => {
+    if (matches.length > 1) {
+      throw new Error(
+        `"${name}" could be ${matches.map((match) => `${match.id} (${match.name})`).join(' or ')}. Use one of those ids.`,
+      );
+    }
+    return matches[0];
+  };
+  const viaId = (id: string) =>
+    byId.get(id) ??
+    pick(fields.filter((field) => fieldSatisfies(field.id, id)));
+  if (isFieldId(name)) return viaId(name);
+  const own = bindings.find((binding) => binding.name === name);
+  // `company_name` that is declared as a podcast's name is not a company name,
+  // so it is read by its id, never by a name that says something else.
+  if (own) {
+    return nameMeanings(name).some((id) => relatedFields(own.id, id))
+      ? byId.get(own.id)
+      : undefined;
+  }
+  if (outputs.includes(name)) return undefined;
+  const found = nameMeanings(name).flatMap((id) => {
+    const binding = viaId(id);
+    return binding ? [binding] : [];
+  });
+  return pick([...new Set(found)]);
+}
+
+/** One place in `result.fields`, and the output that fills it. */
+export type FieldPath = {
+  path: string[];
+  /** The id or short name `result.field()` resolves for this place. */
+  name: string;
+  /** The output read there. Null when two could be, so reading it throws. */
+  output: string | null;
+  list: boolean;
+};
+
+/**
+ * Where each known value of a target sits in `result.fields`. A catalog id
+ * sits at its own path (`person.email.work.value`), and so does the more
+ * general id it answers (`person.email.value`). A short name that resolves
+ * sits at `<name>.value`, as does each declared list. Throws when two land on
+ * the same place, so a tool that would collide fails its build.
+ */
+export function fieldPaths(
+  bindings: readonly FieldBinding[],
+  outputs: readonly string[],
+  lists: readonly string[],
+): FieldPath[] {
+  const names = new Set<string>();
+  for (const binding of bindings) {
+    names.add(binding.id);
+    for (const general of generalFields(binding.id)) names.add(general);
+    names.add(binding.name);
+  }
+  for (const [name, ids] of Object.entries(EXTRACTOR_TARGET_FIELDS)) {
+    if (
+      ids.some((id) =>
+        bindings.some((binding) => fieldSatisfies(binding.id, id)),
+      )
+    ) {
+      names.add(name);
+    }
+  }
+  const paths: FieldPath[] = [];
+  for (const name of names) {
+    let output: string | null;
+    try {
+      const binding = resolveFieldName(name, bindings, outputs);
+      if (!binding) continue;
+      output = binding.name;
+    } catch {
+      // An ambiguous id stays, so reading it names the choices. An ambiguous
+      // short name or record field is only a convenience (a person's and a
+      // company's name are both an entity name), so it is left out.
+      if (!isFieldId(name) || name.startsWith('entity.')) continue;
+      output = null;
+    }
+    // A list keeps its own name; the value is still at its catalog id.
+    if (!isFieldId(name) && lists.includes(name)) continue;
+    const path = isFieldId(name) ? name.split('.') : [name, 'value'];
+    paths.push({ path, name, output, list: false });
+  }
+  for (const name of lists) {
+    paths.push({ path: [name, 'value'], name, output: name, list: true });
+  }
+  const seen = new Set<string>();
+  for (const { path } of paths) {
+    const key = path.join('.');
+    // A leaf cannot also be a parent, nor appear twice.
+    if (
+      seen.has(key) ||
+      paths.some((other) => other.path.join('.').startsWith(`${key}.`))
+    ) {
+      throw new Error(`Two outputs land on result.fields.${key}. Rename one.`);
+    }
+    seen.add(key);
+  }
+  return paths;
+}

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -1,6 +1,50 @@
 import type { EmailStatusExtractorConfig } from './email-status';
 import type { DeeplineGetterValueMap } from './extractor-targets';
 import type { PlayDataset, SerializedPlayDataset } from './dataset';
+import type { FIELD_CATALOG } from './field-catalog';
+
+type Catalog = typeof FIELD_CATALOG;
+
+type GroupLeaves<TGroup> = TGroup extends { leaves: infer TLeaves }
+  ? { readonly [Leaf in keyof TLeaves]?: unknown }
+  : unknown;
+
+type CatalogGroupFields<TGroup> = GroupLeaves<TGroup> &
+  (TGroup extends { kinds: infer TKinds }
+    ? { readonly [Kind in keyof TKinds]?: GroupLeaves<TGroup> }
+    : unknown) &
+  (TGroup extends { groups: infer TGroups }
+    ? {
+        readonly [Child in keyof TGroups]?: CatalogGroupFields<TGroups[Child]>;
+      }
+    : unknown);
+
+/** Every field the catalog defines, as `result.fields` lays them out. */
+export type CatalogFields = {
+  readonly [Entity in keyof Catalog]?: {
+    readonly [Group in keyof Catalog[Entity]]?: CatalogGroupFields<
+      Catalog[Entity][Group]
+    >;
+  };
+} & {
+  /** Provider-specific fields, `provider.<provider>.<...>.<leaf>`. */
+  readonly provider?: Readonly<Record<string, unknown>>;
+};
+
+/**
+ * The values a result is known to have, by field catalog id and short name,
+ * each ending in a leaf: `fields.person.email.value`,
+ * `fields.person.email.work.value`, `fields.email.value`. Declared lists are
+ * at `fields.<list>.value`, as their getter returns them. A value whose
+ * meaning is not known is absent; read it from `response`. Reading a field
+ * two outputs could be throws, naming both.
+ */
+export type ToolResultFields<
+  TExtracted extends Record<string, unknown>,
+  TListValues extends Record<string, unknown>,
+> = CatalogFields & {
+  readonly [K in keyof TExtracted]?: { readonly value: TExtracted[K] | null };
+} & { readonly [K in keyof TListValues]?: { readonly value: TListValues[K] } };
 
 /**
  * Customer pricing reported by the execution API, never provider spend.
@@ -147,6 +191,10 @@ export type BasicToolExecuteResultAccessors<
   extractedLists: {
     [K in keyof TLists]: BasicToolResultListAccessor<TLists[K]>;
   };
+  readonly fields: ToolResultFields<
+    TExtracted,
+    { [K in keyof TLists]: TLists[K][] }
+  >;
 };
 
 /** Public source-SDK result for new Plays; receipts retain the canonical form. */
@@ -260,6 +308,10 @@ export type ToolExecuteResultBase<
   toolResponse: ToolResponseEnvelope<TResult, TMeta>;
   extractedValues: Record<string, ToolResultTargetAccessor>;
   extractedLists: Record<string, ToolResultListAccessor>;
+  /** One field by id or short name, as `fields` resolves it. */
+  field(name: string): unknown;
+  /** The complete parsed provider response (`toolResponse.rawV2`). */
+  readonly response: unknown;
   /** Convenience alias for play code. Serialized output uses toolResponse. */
   toolOutput: ToolResponseEnvelope<TResult, TMeta>;
   _metadata: {
@@ -295,15 +347,23 @@ export type ToolExecuteResultAccessors<
   extractedLists: {
     [K in keyof TLists]: ToolResultListAccessor<TLists[K]>;
   };
+  readonly fields: ToolResultFields<
+    TExtracted,
+    { [K in keyof TLists]: PlayDataset<TLists[K]> }
+  >;
 };
 
 /**
  * Canonical result returned by Deepline tool execution.
  *
- * Provider data: `toolResponse.rawV2`; metadata: `toolResponse.meta`.
- * Single-value getters: `extractedValues.<name>.get()`; lists: `extractedLists.<name>.get()`.
+ * Known values: `fields.person.email.value`, `fields.email.value`, and a
+ * declared list at `fields.<list>.value`; or `field('person.email.value')`.
+ * A value whose meaning is not known is absent: read it from `response`, the
+ * complete provider response. Metadata: `toolResponse.meta`. The older
+ * getters `extractedValues.<name>.get()` and `extractedLists.<name>.get()`
+ * return the same values and keep working.
  *
- * Prefer declared getters. Edition 10 and later Plays receive ordinary arrays from
+ * Edition 10 and later Plays receive ordinary arrays from
  * list `.get()` synchronously; persist explicitly with deepline.dataset. Lazy or
  * incomplete lists throw: use readList(result, path) for explicit dataset access.
  * Provider pagination requires a separate request; getters never fetch it.

package/dist/cli/{auth-LZLBR4C3.mjs → auth-GMSI6QWR.mjs}

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-DHXCBITQ.mjs";
-import "./chunk-WUMIYOXQ.mjs";
-import "./chunk-F2RHUPVH.mjs";
-import "./chunk-I624J4H5.mjs";
+} from "./chunk-CUZVOPPY.mjs";
+import "./chunk-6A7OH2PV.mjs";
+import "./chunk-5CKIO7KA.mjs";
+import "./chunk-MP3O4ISC.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-XDWS2JJT.mjs";
+import "./chunk-J327QVQV.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-P4E7M3AV.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkE4QJKJH6js = require('./chunk-E4QJKJH6.js');
+require('./chunk-O4ZMADW4.js');
+require('./chunk-GVJVBBGV.js');
+require('./chunk-NI3QFUK7.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-4XNXFHG6.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkE4QJKJH6js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkE4QJKJH6js.authStatusLine; exports.clearPendingClaim = _chunkE4QJKJH6js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkE4QJKJH6js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkE4QJKJH6js.handleRegister; exports.handleStatus = _chunkE4QJKJH6js.handleStatus; exports.handleWait = _chunkE4QJKJH6js.handleWait; exports.httpJson = _chunkE4QJKJH6js.httpJson; exports.readPendingAuthClaim = _chunkE4QJKJH6js.readPendingAuthClaim; exports.readStatusBanner = _chunkE4QJKJH6js.readStatusBanner; exports.registerAuthCommands = _chunkE4QJKJH6js.registerAuthCommands; exports.reportSetupCompleted = _chunkE4QJKJH6js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkE4QJKJH6js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkE4QJKJH6js.statusBannerLine;