@rig-c/parts 2.50.0 → 2.51.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/cli.ts CHANGED
@@ -5,7 +5,7 @@ import { DIFF_DRAFTS_SPEC, diffDraftsCommand } from './src/diffdrafts.ts';
5
5
  import { applyTakenLayers } from './src/takelayers.ts';
6
6
  import { applyDepth, bindDepthMap, prepareDepth } from './src/depthworkflow.ts';
7
7
  import { externalReceipt } from './src/externalreceipt.ts';
8
- import { BUST_LANDMARKS_ACT_SCHEMA, BUST_LANDMARKS_PROVENANCE_SPEC, BUST_LANDMARKS_PROVENANCE_SUFFIX, type BustSidecar, planBustLandmarks, readBustSidecar, stageBustLandmarks, stageReplacements, type StagedBustLandmarks } from './src/bustlandmarks.ts';
8
+ import { BUST_LANDMARKS_ACT_SCHEMA, BUST_LANDMARKS_PROVENANCE_SPEC, BUST_LANDMARKS_PROVENANCE_SUFFIX, BUST_POINT_SHAPE_FIELDS, bustShapeClause, type BustSidecar, effectiveBustShape, planBustLandmarks, readBustSidecar, stageBustLandmarks, stageReplacements, type StagedBustLandmarks } from './src/bustlandmarks.ts';
9
9
  import { writeEditedPart } from './tools/edited-part-cli.ts';
10
10
  /**
11
11
  * rig-parts — one painting and its See-through layers in, Spine-ready parts
@@ -32,6 +32,7 @@ import { ACCEPTABLE_BARS, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, findRigc, PACK
32
32
  import { ComfyClient, resolveHost, runBackground, runMatte, runPainting, runSeeThrough } from './src/comfy/index.ts';
33
33
  import { coreCfg, DEFAULT_GROW_PX, runForeground } from './src/plate.ts';
34
34
  import { type CharacterConfig, loadClothConfig, loadConfig, loadEarlyConfig, loadPaintConfig } from './src/config.ts';
35
+ import { type ConfigWritePatch, onlyMissingAttachments } from './src/configwrite.ts';
35
36
  import { configWriteLines, type ConfigWriteTarget, readConfigWriteTarget, separateConfigWriteTarget, stageConfigWrite, type StagedConfigWrite } from './tools/configwrite.ts';
36
37
  import { failLine, guidePointer, PartsError, type Problem } from './src/errors.ts';
37
38
  import { GUIDE_DOC, type GuideAnswer, guideRule, guideSection } from './src/guide.ts';
@@ -42,7 +43,7 @@ import { idleKeysOf, isIdleKeys } from './src/rig.ts';
42
43
  import { bodyCoreBox, bodyOpaqueBox, CORE_ALPHA, depthSkipLine, exportLayers, figuresPhrase, hiddenLayerLine, implausibleRules, layerCoreBox, layerFigures, layerOpaqueBox, type LayerSet, layerSetDiff, type OpaqueBox, OPAQUE_ALPHA_ABOVE, pct, readLayers, readWrapperLayers, ruleSummary, templateLayerNames, templatePsdBytes, times } from './src/layers.ts';
43
44
  import { checkImageSize, choosePerson, KEYPOINTS_SPEC, loadKeypoints, type RigJoints, toRigJoints } from './src/keypoints.ts';
44
45
  import { checkPartsStage } from './src/partscheck.ts';
45
- import { basisLines, branchSqueezeLine, checkProposal, compare, compareLines, DEFAULT_GRID_RULE, draftTurn, drawLandmarks, FIGURE_GRID_DIVISOR, FRINGE_STEP_PX, GRID_RULES, type GridRule, type BustDraft, HIP_MIN_FRACTION, type DraftLintFinding, lint, lintLine, type PartSet, PROPOSAL_CONFIG_SECTIONS, proposalAsConfig, proposeWithBasis, readBustLandmarks, readPartSet, serializeProposal, withTurn, WRIST_ON_PART_PX } from './src/propose.ts';
46
+ import { basisLines, branchSqueezeLine, bustCleavage, checkProposal, compare, compareLines, DEFAULT_GRID_RULE, draftTurn, drawLandmarks, FIGURE_GRID_DIVISOR, FRINGE_STEP_PX, GRID_RULES, type GridRule, type BustDraft, type Proposal, HIP_MIN_FRACTION, type DraftLintFinding, lint, lintLine, type PartSet, PROPOSAL_CONFIG_SECTIONS, proposalAsConfig, proposeWithBasis, readBustLandmarks, readPartSet, serializeProposal, withTurn, WRIST_ON_PART_PX } from './src/propose.ts';
46
47
  import { BASIS_FILE, BASIS_SPEC, basisFile, basisLine, coverageLines, legChainChoice, serializeBasis } from './src/diagnostics.ts';
47
48
  import { BEND_DEGREES, BEND_WORST_SHARE, DUST_MAX_PX, DUST_MAX_SHARE, IDLE_BOUND_PX, MESH_DRAFT_REPORT, MESH_DRAFT_SPEC, meshDraftStage, MORE_TRIANGLES_FLAG, relativeConfigPaths, TOLERANCE_FIGURE_DIVISOR } from './src/meshdraft.ts';
48
49
  import { meshStatsStage } from './src/meshstats.ts';
@@ -266,6 +267,10 @@ usage:
266
267
  rigid sibling unit under the body carrier. Reassembled art is written to
267
268
  <out>/rig; depth comes from the existing scalar input, named in note:.
268
269
  Missing depth, landmarks or clean source is refused, never invented.
270
+ With --bust-landmarks or --no-bust instead of --full and --head, write
271
+ only the chest carrier's contour.bust and bones boob_r/boob_l, every
272
+ other entry as read; a cleavage the file omits is derived from the
273
+ config's own neck and hip bones, and the output says which source.
269
274
 
270
275
  rig-parts propose … [--grid-rule figure|part]
271
276
  How each drafted lattice's spacing (meshes.<part>.grid) is chosen.
@@ -1826,14 +1831,30 @@ function cmdPropose(args: string[]): number {
1826
1831
  if (!existsSync(source)) {
1827
1832
  throw new PartsError([{ code: 'PROPOSE_SOURCE_PRESENT', object: source, detail: 'no such file; the painting is drawn under the overlay' }]);
1828
1833
  }
1834
+ // Issue #1436: on a sampled body-turn neck config the chest flags without the runs write the chest alone.
1835
+ let chestOnly = false;
1829
1836
  if (target !== null && typeof target.raw === 'object' && target.raw !== null && 'turn' in target.raw) {
1830
1837
  const turn = target.raw.turn;
1831
1838
  if (typeof turn === 'object' && turn !== null && 'body' in turn && (loadEarlyConfig(target.path, 'assemble').assemble.plan.some(([, , tag]) => tag === 'neck'))) {
1832
- const unsupported = [...flags.keys()].filter(f => !['--parts', '--source', '--out', '--full', '--head', '--write-config'].includes(f));
1833
- if (unsupported.length > 0) throw new PartsError([{ code: 'PROPOSE_NECK_MODE', object: unsupported.join(', '), detail: 'cannot be combined with the authored sampled-turn neck draft; use --parts, --source, --out, --full, --head and --write-config only; run comparison or landmark drafting separately' }]);
1839
+ const chestFlags = ['--bust-landmarks', '--no-bust'].filter((f) => flags.has(f));
1840
+ const runs = ['--full', '--head'].filter((f) => flags.has(f));
1841
+ const chestCommand = `rig-parts propose --parts <dir> --source <painting.png> --out <dir> --write-config ${writeArg} ${chestFlags.includes('--no-bust') ? '--no-bust "<reason>"' : '--bust-landmarks <landmarks.json>'}`;
1842
+ if (chestFlags.length > 0 && runs.length > 0) {
1843
+ throw new PartsError([{ code: 'PROPOSE_NECK_MODE', object: [...chestFlags, ...runs].join(', '), detail: `the neck draft (--full, --head) and the chest-only write (${chestFlags.join(', ')}) are separate runs on a sampled body-turn neck config; write the chest with ${chestCommand}, without --full and --head, and draft the neck in its own run` }]);
1844
+ }
1845
+ chestOnly = chestFlags.length > 0;
1846
+ const allowed = chestOnly ? ['--parts', '--source', '--out', '--write-config', '--bust-landmarks', '--no-bust'] : ['--parts', '--source', '--out', '--full', '--head', '--write-config'];
1847
+ const unsupported = [...flags.keys()].filter(f => !allowed.includes(f));
1848
+ if (unsupported.length > 0) {
1849
+ throw new PartsError([{ code: 'PROPOSE_NECK_MODE', object: unsupported.join(', '), detail: chestOnly
1850
+ ? `cannot be combined with the chest-only write on a sampled body-turn neck config; use --parts, --source, --out, --write-config and ${chestFlags.join(', ')} only (${chestCommand}); run comparison or other drafting separately`
1851
+ : 'cannot be combined with the authored sampled-turn neck draft; use --parts, --source, --out, --full, --head and --write-config only; run comparison or landmark drafting separately' }]);
1852
+ }
1834
1853
  if (onlyMissing) throw new PartsError([{ code: 'PROPOSE_NECK_MODE', object: '--only-missing', detail: 'cannot replace an attached neck; omit --only-missing for the explicit sampled body-turn neck draft' }]);
1835
- proposeNeck(target, { source, parts: partsDir, out, full: flags.get('--full'), head: flags.get('--head') });
1836
- return EXIT_OK;
1854
+ if (!chestOnly) {
1855
+ proposeNeck(target, { source, parts: partsDir, out, full: flags.get('--full'), head: flags.get('--head') });
1856
+ return EXIT_OK;
1857
+ }
1837
1858
  }
1838
1859
  }
1839
1860
  if (flags.has('--from-config') && (flags.has('--bust-landmarks') || flags.has('--no-bust'))) return usage('--bust-landmarks and --no-bust draft a torso. --from-config reads authored meshes');
@@ -1887,6 +1908,22 @@ function cmdPropose(args: string[]): number {
1887
1908
  separateConfigWriteTarget(target, [sidecar.path]);
1888
1909
  }
1889
1910
  }
1911
+ // Issue #1436: the config is the record, so a cleavage the file leaves out is derived from the config's own midline.
1912
+ let cleavageSource: string | null = null;
1913
+ if (chestOnly && bust.landmarks !== undefined) {
1914
+ if (bust.landmarks.cleavage === undefined) {
1915
+ const declared = loadConfig(target!.path).bones;
1916
+ const at = (name: string): [number, number] => {
1917
+ const bone = declared.find((b) => 'name' in b && b.name === name);
1918
+ if (bone === undefined || !('at' in bone)) throw new PartsError([{ code: 'PROPOSE_BUST_INPUT', object: 'landmarks.cleavage', detail: `is absent and config.bones declares no "${name}" bone with an origin; the config's neck-to-hip midline is required to derive it, or declare cleavage in the landmarks file` }]);
1919
+ return [bone.at[0], bone.at[1]];
1920
+ };
1921
+ const neckAt = at('neck'), hipAt = at('hip');
1922
+ bust.landmarks = { ...bust.landmarks, cleavage: bustCleavage(bust.landmarks.apex_r, bust.landmarks.apex_l, neckAt, hipAt) };
1923
+ cleavageSource = `derived at the apex segment crossing of the config's neck [${neckAt.join(', ')}] -> hip [${hipAt.join(', ')}] midline`;
1924
+ bust.cleavageFrom = cleavageSource;
1925
+ } else cleavageSource = 'from the landmarks file';
1926
+ }
1890
1927
  const { proposal: drafted, basis, draftLint } = proposeWithBasis(P, joints, wristSnap, gridRule, cloth, true, bust);
1891
1928
  const fullRun = flags.get('--full');
1892
1929
  const headRun = flags.get('--head');
@@ -1895,7 +1932,8 @@ function cmdPropose(args: string[]): number {
1895
1932
  ? drafted
1896
1933
  : withTurn(drafted, draftTurn(P, { ...(fullRun === undefined ? {} : { full: readLayers(fullRun) }), ...(headRun === undefined ? {} : { head: readLayers(headRun) }) }, drafted));
1897
1934
  // Emit only after green: a proposal the config loader would refuse is not written, nor a basis record that does not hold to it.
1898
- checkProposal(P, prop);
1935
+ // Issue #1441: the chest carrier's points are checked with the shape the config write will hold.
1936
+ checkProposalWithBustShape(P, prop, target, sidecar, onlyMissing);
1899
1937
  if (sidecar !== null) {
1900
1938
  // The record's part must be the chest carrier this draft makes: points placed on another part are not these.
1901
1939
  const carriers = Object.entries(prop.meshes).filter(([, mesh]) => 'contour' in mesh && mesh.contour.bust !== undefined).map(([part]) => part);
@@ -1939,7 +1977,11 @@ function cmdPropose(args: string[]): number {
1939
1977
  const bfile = basisFile(P, prop, basis, cfg === null || cmpPath === undefined ? null : { where: cmpPath, config: cfg });
1940
1978
  const img = drawLandmarks(P, painting, prop.bones, 'PROPOSAL - CORRECT ME');
1941
1979
  const pending = sidecar?.pending ?? null;
1942
- if (target !== null) staged = stageConfigWrite(target, onlyMissing ? { kind: 'proposal-missing', proposal: prop, parts: P.recs } : { kind: 'proposal', proposal: prop, sections: PROPOSAL_CONFIG_SECTIONS, ...(pending === null ? {} : { bustShape: pending }) });
1980
+ let chest: { patch: Extract<ConfigWritePatch, { kind: 'bust' }>; line: string } | null = null;
1981
+ if (target !== null && chestOnly) {
1982
+ chest = chestOnlyPatch(target, prop, bust, cleavageSource);
1983
+ staged = stageConfigWrite(target, { ...chest.patch, ...(pending === null ? {} : { bustShape: pending }) });
1984
+ } else if (target !== null) staged = stageConfigWrite(target, onlyMissing ? { kind: 'proposal-missing', proposal: prop, parts: P.recs } : { kind: 'proposal', proposal: prop, sections: PROPOSAL_CONFIG_SECTIONS, ...(pending === null ? {} : { bustShape: pending }) });
1943
1985
  else if (written !== null) staged = stageConfigWrite({ kind: 'fresh', path: written.at, text: written.text });
1944
1986
  // The record marked applied is staged after the config and renamed in before the config's commit; a failed
1945
1987
  // config commit puts the record back, so the two change together or not at all.
@@ -1962,6 +2004,7 @@ function cmdPropose(args: string[]): number {
1962
2004
  throw new PartsError(problems);
1963
2005
  }
1964
2006
  if (target !== null) for (const line of configWriteLines(target, staged.changes)) console.error(line);
2007
+ if (chest !== null) console.log(chest.line);
1965
2008
  if (marked !== null && pending !== null && sidecar !== null) {
1966
2009
  console.log(`propose: wrote the pending shape of act ${JSON.stringify(sidecar.provenance.act.act_id)} into meshes.${pending.part}.contour.bust (${pendingFields(pending.fields)}) with the three points; marked it applied in ${sidecar.path}`);
1967
2010
  }
@@ -2731,6 +2774,69 @@ function pendingFields(fields: Readonly<Record<string, number | string | undefin
2731
2774
  return Object.entries(fields).filter(([, v]) => v !== undefined).map(([k, v]) => `${k} ${JSON.stringify(v)}`).join(', ');
2732
2775
  }
2733
2776
 
2777
+ /**
2778
+ * The chest-only write on a sampled body-turn neck config (issue #1436): the chest carrier this draft makes, its
2779
+ * `contour.bust` points (none with --no-bust) and the `boob_r` / `boob_l` bones, as one `bust` patch, and the line
2780
+ * that says what it writes and where the cleavage came from. The config's carrier must already be a contour mesh.
2781
+ */
2782
+ /**
2783
+ * Issue #1441: `checkProposal`, with the chest carrier's `contour.bust` checked against the effective shape
2784
+ * (`effectiveBustShape`): the config's declared shape fields on that part, a pending record's over them, the
2785
+ * defaults for the rest, which is what the config write keeps. The proposal written is the draft as it was. With
2786
+ * no declared or pending alpha or clearance the check is the draft's own, so its refusals read as before; otherwise a
2787
+ * clearance refusal names the shape it used and where each value came from.
2788
+ */
2789
+ function checkProposalWithBustShape(P: PartSet, prop: Proposal, target: ConfigWriteTarget | null, sidecar: BustSidecar | null, onlyMissing: boolean): void {
2790
+ const carrier = Object.entries(prop.meshes).find(([, mesh]) => 'contour' in mesh && mesh.contour.bust !== undefined);
2791
+ if (carrier === undefined || !('contour' in carrier[1]) || carrier[1].contour.bust === undefined) { checkProposal(P, prop); return; }
2792
+ const [part, mesh] = carrier;
2793
+ // --only-missing skips a part the config attaches (the write's own decision), so the draft's points are not
2794
+ // written and the declared shape is not theirs: the draft is checked as drafted, as before #1441.
2795
+ if (onlyMissing && target !== null && onlyMissingAttachments(target.raw).has(part)) { checkProposal(P, prop); return; }
2796
+ const isObject = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
2797
+ const raw = target === null ? undefined : target.raw;
2798
+ const meshes = isObject(raw) && isObject(raw.meshes) ? raw.meshes : undefined;
2799
+ const declaredMesh = meshes !== undefined && Object.hasOwn(meshes, part) ? meshes[part] : undefined;
2800
+ const declared = isObject(declaredMesh) && isObject(declaredMesh.contour) && isObject(declaredMesh.contour.bust) ? declaredMesh.contour.bust : undefined;
2801
+ const pending = sidecar?.pending?.part === part ? sidecar.pending.fields : undefined;
2802
+ const shape = effectiveBustShape(declared, pending);
2803
+ const used = BUST_POINT_SHAPE_FIELDS.filter((key) => shape[key].source !== 'the default');
2804
+ if (used.length === 0) { checkProposal(P, prop); return; }
2805
+ const bust = { ...mesh.contour.bust, ...Object.fromEntries(used.map((key) => [key, shape[key].value])) };
2806
+ // checkProposal's own reader (proposalAsConfig), given the shape values as read: the loader types them.
2807
+ const meshesChecked: Record<string, unknown> = { ...prop.meshes, [part]: { ...mesh, contour: { ...mesh.contour, bust } } };
2808
+ try { proposalAsConfig(P, { ...prop, meshes: meshesChecked }); }
2809
+ catch (error) {
2810
+ if (!(error instanceof PartsError)) throw error;
2811
+ const at = `config.meshes.${part}.contour.bust.clearance`;
2812
+ throw new PartsError(error.problems.map((p) => p.code === 'CONFIG_BUST_CLEARANCE' && p.object === at ? { ...p, detail: `${p.detail}; ${bustShapeClause(shape)}` } : p));
2813
+ }
2814
+ }
2815
+
2816
+ function chestOnlyPatch(target: ConfigWriteTarget, prop: Proposal, bust: BustDraft, cleavageSource: string | null): { patch: Extract<ConfigWritePatch, { kind: 'bust' }>; line: string } {
2817
+ const omitted = (part: string): boolean => prop.notes.some((n) => n.startsWith(`${part}: contour bust omitted for the declared reason: `));
2818
+ const carrier = Object.entries(prop.meshes).find(([part, mesh]) => 'contour' in mesh && (mesh.contour.bust !== undefined || omitted(part)));
2819
+ if (carrier === undefined) {
2820
+ const chestBone = prop.bones.find((b) => 'name' in b && b.name === 'chest');
2821
+ const where = chestBone !== undefined && 'at' in chestBone ? ` at [${chestBone.at.join(', ')}]` : '';
2822
+ throw new PartsError([{ code: 'PROPOSE_BUST_INPUT', object: 'chest carrier', detail: `no topwear art covers chest${where}. A chest-holding topwear part is required for the declared bust input` }]);
2823
+ }
2824
+ const [part, mesh] = carrier;
2825
+ const raw = target.raw as { meshes?: Record<string, unknown> };
2826
+ const declared = typeof raw.meshes === 'object' && raw.meshes !== null ? raw.meshes[part] : undefined;
2827
+ if (typeof declared !== 'object' || declared === null || !('contour' in declared)) {
2828
+ const found = typeof declared !== 'object' || declared === null ? 'no mesh' : `a ${['grid', 'auto', 'influence', 'explicit'].find((m) => m in declared) ?? 'non-contour'} mesh`;
2829
+ throw new PartsError([{ code: 'PROPOSE_BUST_CARRIER_MESH', object: `config.meshes.${part}`, detail: `is ${found}; the chest-only write on a sampled body-turn neck config sets contour.bust on the chest carrier's contour mesh, which it does not draft. Produce one in this order: rig-parts propose … --write-config <config> --no-bust "<reason>" before turn.body is written, then write turn.body and draft the neck` }]);
2830
+ }
2831
+ const points = 'contour' in mesh ? mesh.contour.bust : undefined;
2832
+ const bones = prop.bones.filter((b): b is { name: string; parent: string; at: [number, number] } => 'name' in b && (b.name === 'boob_r' || b.name === 'boob_l') && 'at' in b).map((b) => ({ name: b.name, parent: b.parent, at: [b.at[0], b.at[1]] }));
2833
+ const patch: Extract<ConfigWritePatch, { kind: 'bust' }> = { kind: 'bust', part, bust: points === undefined || points.cleavage === undefined ? null : { apex_r: [...points.apex_r], apex_l: [...points.apex_l], cleavage: [...points.cleavage] }, bones };
2834
+ const line = patch.bust === null
2835
+ ? `propose: chest-only write on the sampled body-turn neck config: meshes.${part}.contour.bust and bones boob_r, boob_l removed where present (--no-bust: ${bust.noBust ?? ''}); every other entry as read`
2836
+ : `propose: chest-only write on the sampled body-turn neck config: meshes.${part}.contour.bust apex_r ${JSON.stringify(patch.bust.apex_r)} apex_l ${JSON.stringify(patch.bust.apex_l)} cleavage ${JSON.stringify(patch.bust.cleavage)} (${cleavageSource ?? 'from the landmarks file'}); bones boob_r, boob_l under chest at the apices; every other entry as read`;
2837
+ return { patch, line };
2838
+ }
2839
+
2734
2840
  function cmdBustLandmarks(args: string[]): number {
2735
2841
  // The one switch (issue #1382, round 2): taken out before the valued flags are read.
2736
2842
  const writes = args.filter((a) => a === '--write-config').length;
@@ -2774,11 +2880,16 @@ function cmdBustLandmarks(args: string[]): number {
2774
2880
  if (target !== null) for (const line of configWriteLines(target, staged?.changes ?? [])) console.error(line);
2775
2881
  console.log(`bust-landmarks: slot "${provenance.slot}" apex_r ${JSON.stringify(landmarks.apex_r)} apex_l ${JSON.stringify(landmarks.apex_l)} cleavage ${landmarks.cleavage === undefined ? 'absent (propose derives it)' : JSON.stringify(landmarks.cleavage)}; act ${JSON.stringify(provenance.act.act_id)} sha256=${provenance.act.file_sha256} row sha256=${provenance.row_sha256} (verified against the row's edit)`);
2776
2882
  const shape = provenance.shape;
2777
- if (shape === undefined) console.log(`wrote ${plan.out} and ${plan.provenancePath}; next: rig-parts propose … --bust-landmarks ${plan.out}`);
2883
+ // Issue #1436: both lines name the command that writes the points into the config; without --write-config,
2884
+ // propose writes only proposal.json.
2885
+ const next = `wrote ${plan.out} and ${plan.provenancePath}; next, to apply it: rig-parts propose … --write-config ${resolve(input.config)} --bust-landmarks ${plan.out}`;
2886
+ if (shape === undefined) console.log(next);
2778
2887
  else {
2779
2888
  // Issue #1382: the config declares no contour.bust, so the reviewed shape waits in the record for propose.
2780
- console.log(`bust-landmarks: pending shape for "${provenance.slot}": ${pendingFields(shape.fields)}; the config declares no contour.bust yet, so ${plan.provenancePath} carries it until propose writes it with the three points`);
2781
- console.log(`wrote ${plan.out} and ${plan.provenancePath}; next, to apply it: rig-parts propose … --write-config ${resolve(input.config)} --bust-landmarks ${plan.out}`);
2889
+ // Issue #1443: or the act moved the declared points, and the shape is not written against the old ones.
2890
+ const why = plan.moved ? `the act moves the points of meshes.${provenance.slot}.contour.bust, so the config is not written and` : 'the config declares no contour.bust yet, so';
2891
+ console.log(`bust-landmarks: pending shape for "${provenance.slot}": ${pendingFields(shape.fields)}; ${why} ${plan.provenancePath} carries it until propose writes it with the three points`);
2892
+ console.log(next);
2782
2893
  }
2783
2894
  return EXIT_OK;
2784
2895
  } catch (error) { return printRefusal(error); }