@proposit/proposit-core 1.1.1 → 1.3.0

package/dist/extensions/argument-ingestion/index.d.ts

@@ -1,9 +1,13 @@
 export { createIngestionV1Pipeline } from "./v1-single-shot.js";
 export type { TCreateIngestionV1PipelineOptions } from "./v1-single-shot.js";
+export { createIngestionV2Pipeline } from "./v2-multi-stage.js";
 export { basicsExtension } from "./shared/basics-extension.js";
 export type { TIngestionExtension, TIngestionInput } from "./shared/types.js";
 export { finalizeResponse } from "./shared/finalize-response.js";
 export type { TFinalizeResponseInput } from "./shared/finalize-response.js";
+export { finalizeResponseV2, FINALIZE_V2_FAILURE_TEXTS, } from "./shared/finalize-response-v2.js";
+export type { TFinalizeResponseV2Input } from "./shared/finalize-response-v2.js";
 export { deriveRoles } from "./shared/role-derivation.js";
 export type { TClaimRole, TDeriveRolesInput } from "./shared/role-derivation.js";
+export * from "./stages/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/extensions/argument-ingestion/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,YAAY,EAAE,iCAAiC,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,YAAY,EAAE,iCAAiC,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EACH,kBAAkB,EAClB,yBAAyB,GAC5B,MAAM,kCAAkC,CAAA;AACzC,YAAY,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAA;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAGhF,cAAc,mBAAmB,CAAA"}

package/dist/extensions/argument-ingestion/index.js

@@ -1,11 +1,16 @@
 // Barrel for the argument-ingestion extension.
 //
-// Exposes the v1 single-shot pipeline factory + the default
-// `basicsExtension`. v2 (Phase 2 / slice 2A) will add
-// `createIngestionV2Pipeline` alongside the v1 entry-point; the
-// `TIngestionExtension` descriptor is forward-compatible across both.
+// Exposes the v1 single-shot pipeline factory + the v2 multi-stage
+// pipeline factory + the default `basicsExtension`. The shared
+// `TIngestionExtension` descriptor is forward-compatible across both
+// pipelines.
 export { createIngestionV1Pipeline } from "./v1-single-shot.js";
+export { createIngestionV2Pipeline } from "./v2-multi-stage.js";
 export { basicsExtension } from "./shared/basics-extension.js";
 export { finalizeResponse } from "./shared/finalize-response.js";
+export { finalizeResponseV2, FINALIZE_V2_FAILURE_TEXTS, } from "./shared/finalize-response-v2.js";
 export { deriveRoles } from "./shared/role-derivation.js";
+// Per-stage exports — surfaced for consumers (e.g. observability
+// bridges) that want to key on stage ids without re-stringifying.
+export * from "./stages/index.js";
 //# sourceMappingURL=index.js.map

package/dist/extensions/argument-ingestion/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,4DAA4D;AAC5D,sDAAsD;AACtD,gEAAgE;AAChE,sEAAsE;AAEtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAE9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/argument-ingestion/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,mEAAmE;AACnE,+DAA+D;AAC/D,qEAAqE;AACrE,aAAa;AAEb,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAE9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,EACH,kBAAkB,EAClB,yBAAyB,GAC5B,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,iEAAiE;AACjE,kEAAkE;AAClE,cAAc,mBAAmB,CAAA"}

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.d.ts

@@ -0,0 +1,17 @@
+import type { TParsedArgumentResponse } from "../../../lib/parsing/index.js";
+import type { TStageContext } from "../../../lib/pipelines/index.js";
+import type { TIngestionExtension } from "./types.js";
+export declare const FINALIZE_V2_FAILURE_TEXTS: {
+    readonly noClaims: "No claims could be extracted from the input.";
+    readonly noConclusion: "No single conclusion could be selected.";
+};
+export type TFinalizeResponseV2Input = {
+    ctx: TStageContext;
+    extension: TIngestionExtension;
+};
+/**
+ * Assembles the v2 pipeline's final response from the
+ * `TStageContext`'s accumulated upstream outputs.
+ */
+export declare function finalizeResponseV2(input: TFinalizeResponseV2Input): TParsedArgumentResponse;
+//# sourceMappingURL=finalize-response-v2.d.ts.map

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize-response-v2.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/finalize-response-v2.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAWpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAErD,eAAO,MAAM,yBAAyB;;;CAG5B,CAAA;AAyGV,MAAM,MAAM,wBAAwB,GAAG;IACnC,GAAG,EAAE,aAAa,CAAA;IAClB,SAAS,EAAE,mBAAmB,CAAA;CACjC,CAAA;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,wBAAwB,GAChC,uBAAuB,CA2GzB"}

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.js

@@ -0,0 +1,185 @@
+// `finalize-response-v2` — assembles the v2 multi-stage pipeline's
+// final `TParsedArgumentResponse`-shaped output from accumulated
+// per-stage outputs.
+//
+// Behavior per spec §7.2 finalize row + §7.4 (role derivation) +
+// §7.5 (failure model):
+//
+//   - When `claim-canonicalization.canonicalClaims` is empty:
+//     `{ argument: null, failureText: "No claims could be extracted
+//     from the input.", uncategorizedText: null,
+//     selectionRationale: null, processingFailures: [] }`.
+//
+//   - When `formula-compilation.conclusionPremiseMiniId` is null
+//     (conclusion-selection returned null, or the conclusion claim
+//     wasn't resolvable to a symbol): `{ argument: null,
+//     failureText: "No single conclusion could be selected.", ... }`.
+//
+//   - Otherwise: assemble the full argument from the canonical claims
+//     (with per-claim role derived from `relation-extraction` +
+//     `conclusion-selection`), the variables from `variable-assignment`,
+//     and the premises from `formula-compilation`. The `selectionRationale`
+//     field is `conclusion-selection.rationale` (or null when the
+//     stage is missing).
+//
+// **`processingFailures` slot.** Mirroring v1's convention, finalize
+// always emits an empty `processingFailures: []` array on the output.
+// The full list of per-stage failures lives on `PipelineResult.failures`
+// — consumers that want them read that field. The slot on the response
+// object is a forward-compat hook; the framework doesn't have a clean
+// way for `finalize.run` to consult the executor's accumulated failure
+// list (which would require widening `TStageContext` — out of scope
+// for slice 2A.late).
+import { STAGE_IDS, } from "../stages/schemas.js";
+export const FINALIZE_V2_FAILURE_TEXTS = {
+    noClaims: "No claims could be extracted from the input.",
+    noConclusion: "No single conclusion could be selected.",
+};
+function buildClaimToRole(args) {
+    const out = {};
+    // Claims that participate in any relation (source or target) are
+    // "premise" by default; claims that don't appear in any relation
+    // are "intermediate" (per spec §7.4). The conclusion overrides.
+    const claimsInRelations = new Set();
+    for (const rel of args.relations) {
+        for (const s of rel.sources)
+            claimsInRelations.add(s);
+        claimsInRelations.add(rel.target);
+    }
+    for (const claim of args.canonicalClaims) {
+        if (claim.miniId === args.conclusionMiniId) {
+            out[claim.miniId] = "conclusion";
+        }
+        else if (claimsInRelations.has(claim.miniId)) {
+            out[claim.miniId] = "premise";
+        }
+        else {
+            out[claim.miniId] = "intermediate";
+        }
+    }
+    return out;
+}
+function stripCanonicalizerOnlyFields(claim) {
+    // The canonicalizer's per-claim record carries `mentionIds` and
+    // `suggestedSymbol` which are not part of the public response
+    // schema. Strip them from the finalize output (the variable's
+    // `symbol` carries the assigned identifier; mentionIds are an
+    // internal trace).
+    const stripped = {};
+    for (const [key, value] of Object.entries(claim)) {
+        if (key === "mentionIds" || key === "suggestedSymbol")
+            continue;
+        stripped[key] = value;
+    }
+    return stripped;
+}
+function buildPremiseTitle(formula, roleHint) {
+    const cap = 50;
+    const truncate = (s) => s.length <= cap ? s : s.slice(0, cap - 1) + "…";
+    switch (roleHint) {
+        case "conclusion":
+            return truncate(`Conclusion: ${formula}`);
+        case "joint-support":
+            return truncate(`Joint support → ${formula}`);
+        case "derivation":
+            return truncate(`Derivation: ${formula}`);
+        case "support":
+            return truncate(`Support: ${formula}`);
+    }
+}
+function buildArgumentTitle(canonicalClaims, conclusionMiniId) {
+    const cap = 50;
+    const conclusionClaim = canonicalClaims.find((c) => c.miniId === conclusionMiniId);
+    const candidateTitle = conclusionClaim?.title ??
+        conclusionClaim?.axiom ??
+        "Argument";
+    return candidateTitle.length <= cap
+        ? candidateTitle
+        : candidateTitle.slice(0, cap - 1) + "…";
+}
+/**
+ * Assembles the v2 pipeline's final response from the
+ * `TStageContext`'s accumulated upstream outputs.
+ */
+export function finalizeResponseV2(input) {
+    void input.extension; // forward-compat (extension-specific assembly hooks)
+    const { ctx } = input;
+    const canon = ctx.get(STAGE_IDS.claimCanonicalization);
+    const variables = ctx.get(STAGE_IDS.variableAssignment) ?? [];
+    const compilation = ctx.get(STAGE_IDS.formulaCompilation);
+    const conclusion = ctx.get(STAGE_IDS.conclusionSelection);
+    const relationEnvelope = ctx.get(STAGE_IDS.relationExtraction);
+    const relations = relationEnvelope?.relations ?? [];
+    const typeEnvelope = ctx.get(STAGE_IDS.claimTypeClassification);
+    const typeByMiniId = new Map();
+    for (const entry of typeEnvelope?.classifications ?? []) {
+        typeByMiniId.set(entry.miniId, entry);
+    }
+    const processingFailures = [];
+    const baseResponse = {
+        uncategorizedText: null,
+        selectionRationale: conclusion?.rationale ?? null,
+    };
+    // Failure path 1: no canonical claims at all.
+    if (!canon || canon.canonicalClaims.length === 0) {
+        return {
+            argument: null,
+            failureText: FINALIZE_V2_FAILURE_TEXTS.noClaims,
+            ...baseResponse,
+            // `processingFailures` is a side-channel slot the v1
+            // finalize also attaches; the response schema permits
+            // additional properties.
+            processingFailures,
+        };
+    }
+    // Failure path 2: no single conclusion could be selected (or the
+    // conclusion claim has no resolvable variable, in which case
+    // formula-compilation already emitted an unresolved-conclusion
+    // failure and left conclusionPremiseMiniId null).
+    if (compilation?.conclusionPremiseMiniId === null || !compilation) {
+        return {
+            argument: null,
+            failureText: FINALIZE_V2_FAILURE_TEXTS.noConclusion,
+            ...baseResponse,
+            processingFailures,
+        };
+    }
+    // Happy path: assemble the argument.
+    const conclusionMiniId = conclusion?.conclusionMiniId ?? null;
+    const roles = buildClaimToRole({
+        canonicalClaims: canon.canonicalClaims,
+        relations,
+        conclusionMiniId,
+    });
+    const claims = canon.canonicalClaims.map((c) => {
+        const refinedType = typeByMiniId.get(c.miniId)?.type ?? c.type;
+        const stripped = stripCanonicalizerOnlyFields(c);
+        return {
+            ...stripped,
+            type: refinedType,
+            role: roles[c.miniId],
+        };
+    });
+    const finalVariables = variables.map((v) => ({
+        ...v,
+    }));
+    const finalPremises = compilation.premises.map((p) => ({
+        miniId: p.premiseMiniId,
+        formula: p.formula,
+        title: buildPremiseTitle(p.formula, p.roleHint),
+    }));
+    const argument = {
+        claims,
+        variables: finalVariables,
+        premises: finalPremises,
+        conclusionPremiseMiniId: compilation.conclusionPremiseMiniId,
+        title: buildArgumentTitle(canon.canonicalClaims, conclusionMiniId),
+    };
+    return {
+        argument: argument,
+        failureText: null,
+        ...baseResponse,
+        processingFailures,
+    };
+}
+//# sourceMappingURL=finalize-response-v2.js.map

package/dist/extensions/argument-ingestion/shared/finalize-response-v2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize-response-v2.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/shared/finalize-response-v2.ts"],"names":[],"mappings":"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"}

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.d.ts

@@ -0,0 +1,6 @@
+import { type TAxiomIndicatorDetectionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+export declare const AXIOM_INDICATOR_DETECTION_MODEL = "gpt-5.4-mini";
+export declare const AXIOM_INDICATOR_DETECTION_SYSTEM_PROMPT = "You scan the segments of an argument for axiom indicators \u2014 explicit signals that the author is invoking a self-evident truth as bottom-level support.\n\nRecognized indicator patterns include (non-exhaustive):\n- \"by definition\"\n- \"tautologically\", \"necessarily true\"\n- \"by convention\"\n- \"is true a priori\"\n- \"as a matter of (logic | mathematics | definition)\"\n- \"trivially\"\n\nReturn an object with a single key `axioms` whose value is the array of detected indicators. For each detected indicator emit:\n- a fresh \"axiomId\" (ax1, ax2, ...)\n- the list of \"segmentIds\" the indicator occurs in (usually one; sometimes two when the indicator straddles a clause)\n- the \"indicator\" \u2014 the verbatim trigger phrase\n- the character \"spans\" \u2014 one span object (\"start\" inclusive, \"end\" exclusive) per occurrence, relative to the SEGMENT'S TEXT\n\nHedging phrases (\"clearly\", \"obviously\", \"of course\") are NOT axiom indicators on their own \u2014 they are stylistic emphasis. Return `{ \"axioms\": [] }` when no indicators are present.";
+export declare const axiomIndicatorDetectionStage: TStage<TAxiomIndicatorDetectionOutput>;
+//# sourceMappingURL=axiom-indicator-detection.d.ts.map

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axiom-indicator-detection.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/axiom-indicator-detection.ts"],"names":[],"mappings":"AAKA,OAAO,EAGH,KAAK,8BAA8B,EAEtC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAE5E,eAAO,MAAM,+BAA+B,iBAAiB,CAAA;AAE7D,eAAO,MAAM,uCAAuC,4jCAgBmI,CAAA;AAavL,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,8BAA8B,CAO1E,CAAA"}

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.js

@@ -0,0 +1,42 @@
+// `axiom-indicator-detection` — detects places where the author
+// invokes a self-evident truth (axiom) as the bottom-level support of
+// some claim. Phrases like "by definition", "by convention",
+// "as a matter of logic", "is necessarily true" mark the spots.
+import { STAGE_IDS, AxiomIndicatorDetectionOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const AXIOM_INDICATOR_DETECTION_MODEL = "gpt-5.4-mini";
+export const AXIOM_INDICATOR_DETECTION_SYSTEM_PROMPT = `You scan the segments of an argument for axiom indicators — explicit signals that the author is invoking a self-evident truth as bottom-level support.
+
+Recognized indicator patterns include (non-exhaustive):
+- "by definition"
+- "tautologically", "necessarily true"
+- "by convention"
+- "is true a priori"
+- "as a matter of (logic | mathematics | definition)"
+- "trivially"
+
+Return an object with a single key \`axioms\` whose value is the array of detected indicators. For each detected indicator emit:
+- a fresh "axiomId" (ax1, ax2, ...)
+- the list of "segmentIds" the indicator occurs in (usually one; sometimes two when the indicator straddles a clause)
+- the "indicator" — the verbatim trigger phrase
+- the character "spans" — one span object ("start" inclusive, "end" exclusive) per occurrence, relative to the SEGMENT'S TEXT
+
+Hedging phrases ("clearly", "obviously", "of course") are NOT axiom indicators on their own — they are stylistic emphasis. Return \`{ "axioms": [] }\` when no indicators are present.`;
+function buildPrompt(ctx) {
+    const segmentation = ctx.get(STAGE_IDS.segmentation);
+    const segments = segmentation?.segments ?? [];
+    const renderedSegments = segments
+        .map((s) => `[${s.segmentId}] ${JSON.stringify(s.text)}`)
+        .join("\n");
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.axiomIndicatorDetection} -->\n${AXIOM_INDICATOR_DETECTION_SYSTEM_PROMPT}`;
+    const user = `Segments:\n\n${renderedSegments}\n\nDetect every axiom indicator.`;
+    return { system: markedSystem, user };
+}
+export const axiomIndicatorDetectionStage = llmStage({
+    id: STAGE_IDS.axiomIndicatorDetection,
+    dependsOn: [STAGE_IDS.segmentation],
+    outputSchema: AxiomIndicatorDetectionOutputSchema,
+    model: AXIOM_INDICATOR_DETECTION_MODEL,
+    buildPrompt,
+});
+//# sourceMappingURL=axiom-indicator-detection.js.map

package/dist/extensions/argument-ingestion/stages/axiom-indicator-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axiom-indicator-detection.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/axiom-indicator-detection.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,sEAAsE;AACtE,6DAA6D;AAC7D,gEAAgE;AAEhE,OAAO,EACH,SAAS,EACT,mCAAmC,GAGtC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAA;AAGlE,MAAM,CAAC,MAAM,+BAA+B,GAAG,cAAc,CAAA;AAE7D,MAAM,CAAC,MAAM,uCAAuC,GAAG;;;;;;;;;;;;;;;;uLAgBgI,CAAA;AAEvL,SAAS,WAAW,CAAC,GAAkB;IACnC,MAAM,YAAY,GAAG,GAAG,CAAC,GAAG,CAAsB,SAAS,CAAC,YAAY,CAAC,CAAA;IACzE,MAAM,QAAQ,GAAG,YAAY,EAAE,QAAQ,IAAI,EAAE,CAAA;IAC7C,MAAM,gBAAgB,GAAG,QAAQ;SAC5B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;SACxD,IAAI,CAAC,IAAI,CAAC,CAAA;IACf,MAAM,YAAY,GAAG,kBAAkB,SAAS,CAAC,uBAAuB,SAAS,uCAAuC,EAAE,CAAA;IAC1H,MAAM,IAAI,GAAG,gBAAgB,gBAAgB,mCAAmC,CAAA;IAChF,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAA;AACzC,CAAC;AAED,MAAM,CAAC,MAAM,4BAA4B,GACrC,QAAQ,CAAiC;IACrC,EAAE,EAAE,SAAS,CAAC,uBAAuB;IACrC,SAAS,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC;IACnC,YAAY,EAAE,mCAAmC;IACjD,KAAK,EAAE,+BAA+B;IACtC,WAAW;CACd,CAAC,CAAA"}

package/dist/extensions/argument-ingestion/stages/citation-source-detection.d.ts

@@ -0,0 +1,6 @@
+import { type TCitationSourceDetectionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+export declare const CITATION_SOURCE_DETECTION_MODEL = "gpt-5.4-mini";
+export declare const CITATION_SOURCE_DETECTION_SYSTEM_PROMPT = "You scan the segments of an argument for explicit references to external sources of evidence.\n\nA source reference is any of:\n- a Markdown link: `[label](url)`\n- a named source: \"according to X\", \"as reported in Y\", \"the X report\"\n- a bracketed citation marker: `[1]`, `[Smith 2024]`\n- a fully-qualified URL\n\nReturn an object with a single key `sources` whose value is the array of detected source references. For each detected source emit:\n- a fresh \"sourceId\" (src1, src2, ...)\n- the list of \"segmentIds\" the source occurs in (almost always one; multi-segment when one citation spans a clause boundary)\n- a short \"sourceString\" \u2014 the human-readable label (e.g. \"NASA climate report\", \"Smith 2024\")\n- the \"url\" field \u2014 the URL when one is present, otherwise null\n- the character \"spans\" \u2014 one span object (\"start\" inclusive, \"end\" exclusive) per occurrence, relative to the SEGMENT'S TEXT\n\nDo not detect mere mentions of people, organizations, or studies that are not invoked as supporting evidence. Quote attribution alone (\"Bob said X\") is not a citation unless Bob's saying is being used to support a claim. Return `{ \"sources\": [] }` when no sources are present.";
+export declare const citationSourceDetectionStage: TStage<TCitationSourceDetectionOutput>;
+//# sourceMappingURL=citation-source-detection.d.ts.map

package/dist/extensions/argument-ingestion/stages/citation-source-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-source-detection.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/citation-source-detection.ts"],"names":[],"mappings":"AAMA,OAAO,EAGH,KAAK,8BAA8B,EAEtC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAE5E,eAAO,MAAM,+BAA+B,iBAAiB,CAAA;AAE7D,eAAO,MAAM,uCAAuC,6sCAemO,CAAA;AAavR,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,8BAA8B,CAO1E,CAAA"}

package/dist/extensions/argument-ingestion/stages/citation-source-detection.js

@@ -0,0 +1,42 @@
+// `citation-source-detection` — detects explicit source references in
+// the segmented input. Markdown links, "according to X", named
+// reports/papers, bracketed citation markers, etc. The downstream
+// `claim-canonicalization` stage uses this to route the right claims
+// to citation-typed records with their `url` / `title` populated.
+import { STAGE_IDS, CitationSourceDetectionOutputSchema, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+export const CITATION_SOURCE_DETECTION_MODEL = "gpt-5.4-mini";
+export const CITATION_SOURCE_DETECTION_SYSTEM_PROMPT = `You scan the segments of an argument for explicit references to external sources of evidence.
+
+A source reference is any of:
+- a Markdown link: \`[label](url)\`
+- a named source: "according to X", "as reported in Y", "the X report"
+- a bracketed citation marker: \`[1]\`, \`[Smith 2024]\`
+- a fully-qualified URL
+
+Return an object with a single key \`sources\` whose value is the array of detected source references. For each detected source emit:
+- a fresh "sourceId" (src1, src2, ...)
+- the list of "segmentIds" the source occurs in (almost always one; multi-segment when one citation spans a clause boundary)
+- a short "sourceString" — the human-readable label (e.g. "NASA climate report", "Smith 2024")
+- the "url" field — the URL when one is present, otherwise null
+- the character "spans" — one span object ("start" inclusive, "end" exclusive) per occurrence, relative to the SEGMENT'S TEXT
+
+Do not detect mere mentions of people, organizations, or studies that are not invoked as supporting evidence. Quote attribution alone ("Bob said X") is not a citation unless Bob's saying is being used to support a claim. Return \`{ "sources": [] }\` when no sources are present.`;
+function buildPrompt(ctx) {
+    const segmentation = ctx.get(STAGE_IDS.segmentation);
+    const segments = segmentation?.segments ?? [];
+    const renderedSegments = segments
+        .map((s) => `[${s.segmentId}] ${JSON.stringify(s.text)}`)
+        .join("\n");
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.citationSourceDetection} -->\n${CITATION_SOURCE_DETECTION_SYSTEM_PROMPT}`;
+    const user = `Segments:\n\n${renderedSegments}\n\nDetect every citation/source reference.`;
+    return { system: markedSystem, user };
+}
+export const citationSourceDetectionStage = llmStage({
+    id: STAGE_IDS.citationSourceDetection,
+    dependsOn: [STAGE_IDS.segmentation],
+    outputSchema: CitationSourceDetectionOutputSchema,
+    model: CITATION_SOURCE_DETECTION_MODEL,
+    buildPrompt,
+});
+//# sourceMappingURL=citation-source-detection.js.map

package/dist/extensions/argument-ingestion/stages/citation-source-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-source-detection.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/citation-source-detection.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,+DAA+D;AAC/D,kEAAkE;AAClE,qEAAqE;AACrE,kEAAkE;AAElE,OAAO,EACH,SAAS,EACT,mCAAmC,GAGtC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAA;AAGlE,MAAM,CAAC,MAAM,+BAA+B,GAAG,cAAc,CAAA;AAE7D,MAAM,CAAC,MAAM,uCAAuC,GAAG;;;;;;;;;;;;;;;uRAegO,CAAA;AAEvR,SAAS,WAAW,CAAC,GAAkB;IACnC,MAAM,YAAY,GAAG,GAAG,CAAC,GAAG,CAAsB,SAAS,CAAC,YAAY,CAAC,CAAA;IACzE,MAAM,QAAQ,GAAG,YAAY,EAAE,QAAQ,IAAI,EAAE,CAAA;IAC7C,MAAM,gBAAgB,GAAG,QAAQ;SAC5B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;SACxD,IAAI,CAAC,IAAI,CAAC,CAAA;IACf,MAAM,YAAY,GAAG,kBAAkB,SAAS,CAAC,uBAAuB,SAAS,uCAAuC,EAAE,CAAA;IAC1H,MAAM,IAAI,GAAG,gBAAgB,gBAAgB,6CAA6C,CAAA;IAC1F,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAA;AACzC,CAAC;AAED,MAAM,CAAC,MAAM,4BAA4B,GACrC,QAAQ,CAAiC;IACrC,EAAE,EAAE,SAAS,CAAC,uBAAuB;IACrC,SAAS,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC;IACnC,YAAY,EAAE,mCAAmC;IACjD,KAAK,EAAE,+BAA+B;IACtC,WAAW;CACd,CAAC,CAAA"}

package/dist/extensions/argument-ingestion/stages/claim-canonicalization.d.ts

@@ -0,0 +1,15 @@
+import { type TClaimCanonicalizationOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+import type { TIngestionExtension } from "../shared/types.js";
+export declare const CLAIM_CANONICALIZATION_MODEL = "gpt-5.5";
+export declare const CLAIM_CANONICALIZATION_REASONING: "minimal" | "low" | "medium" | "high";
+export declare const CLAIM_CANONICALIZATION_SYSTEM_PROMPT = "You merge raw claim mentions into a single canonical set of claims for an argument-ingestion pipeline.\n\nYou are given:\n- the raw input text (for full context)\n- the segmented breakdown of the text\n- the list of every claim mention extracted from those segments\n- optionally, the detected citation sources + axiom indicators\n\nYour output has two parts:\n\n1. `canonicalClaims` \u2014 an array of canonical claims, one entry per distinct proposition the author makes. Two mentions that assert the same proposition (even when phrased differently across the text) merge into a single canonical claim. Each canonical claim carries:\n   - `miniId` \u2014 assign in canonicalization order: c1, c2, c3, ...\n   - `mentionIds` \u2014 list of the mention ids that resolved to this claim\n   - `type` \u2014 one of \"normal\", \"citation\", or \"axiomatic\" (see below)\n   - `suggestedSymbol` \u2014 a short PascalCase-or-snake_case identifier summarizing the claim (e.g. \"Rain_Wets_Ground\", \"NASA_Temp_Rise\", \"Socrates_Mortal\"). Use letters, digits, and underscores only; start with a letter or underscore; keep under 32 characters; aim for under 20. AVOID single letters and generic names like \"Claim1\".\n   - the extension fields described in your output schema (title, body, url, axiom \u2014 whichever apply to the claim's `type`)\n\n2. `mentionToClaim` \u2014 an array of `{ \"mentionId\": \"...\", \"claimMiniId\": \"...\" }` entries, one per input mention. Every input mentionId must appear in exactly one entry; the mapping is total. (We surface this as a list rather than a map because the response schema does not allow arbitrary string keys.)\n\n## Claim types\n\n- `\"normal\"` \u2014 a primary proposition the argument argues for or from.\n- `\"citation\"` \u2014 a claim whose content is \"the cited source asserts X\". Use this type when one of the citation sources covers the same span(s) as the mention. Populate `url` (the URL if present) and `title` (a short human-readable label).\n- `\"axiomatic\"` \u2014 a claim invoked as self-evident truth. Use this type when an axiom indicator (e.g. \"by definition\") covers or precedes the mention. Populate `axiom` with the gist of the self-evident proposition.\n\nWhen a mention is the antecedent of \"according to X, P\", split it into two claims: a citation-typed claim for the source itself + a normal-typed claim for the proposition. The two are connected via a relation in a later stage, not here.\n\n## Style\n\n- Claim titles + bodies are written in third-person, present-tense, active voice.\n- Titles are short (\u2264 50 characters); bodies fill in the detail.\n- For citation claims, the title summarizes what the source asserts (e.g. \"NASA reports temperature rise\"); the URL goes in `url`.\n- For axiomatic claims, the `axiom` field captures the self-evident proposition (e.g. \"A bachelor is an unmarried man by definition.\").\n\nOutput ONLY the schema-shaped object. No prose.";
+/**
+ * Builds the `claim-canonicalization` stage for the supplied
+ * extension. The stage's `outputSchema` carries the extension's
+ * per-claim fields, so the LLM's structured-output schema matches the
+ * extension's claim shape (e.g. for `basics`: a discriminated union
+ * over `type`).
+ */
+export declare function createClaimCanonicalizationStage(extension: TIngestionExtension): TStage<TClaimCanonicalizationOutput>;
+//# sourceMappingURL=claim-canonicalization.d.ts.map

package/dist/extensions/argument-ingestion/stages/claim-canonicalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-canonicalization.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-canonicalization.ts"],"names":[],"mappings":"AAiBA,OAAO,EAMH,KAAK,4BAA4B,EACpC,MAAM,cAAc,CAAA;AAGrB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAmB,MAAM,oBAAoB,CAAA;AAE9E,eAAO,MAAM,4BAA4B,YAAY,CAAA;AACrD,eAAO,MAAM,gCAAgC,EACvC,SAAS,GACT,KAAK,GACL,QAAQ,GACR,MAAiB,CAAA;AAEvB,eAAO,MAAM,oCAAoC,05FAkCD,CAAA;AA8GhD;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC5C,SAAS,EAAE,mBAAmB,GAC/B,MAAM,CAAC,4BAA4B,CAAC,CAatC"}

package/dist/extensions/argument-ingestion/stages/claim-canonicalization.js

@@ -0,0 +1,148 @@
+// `claim-canonicalization` — merges the raw mentions into a single
+// canonical claim set. Each canonical claim carries:
+//   - a miniId (c1, c2, ...) allocated by the stage
+//   - the mentionIds it absorbed
+//   - a `suggestedSymbol` — the canonicalizer's snake_case-shaped
+//     proposal (validated downstream by variable-assignment)
+//   - the extension's per-claim fields (e.g. for `basics`: a
+//     discriminated union over `type` with title/body/url/axiom)
+//
+// `mentionToClaim` maps every mention id back to its assigned
+// canonical claim's miniId — useful for downstream stages (and
+// finalize) that want to trace evidence back to the text.
+//
+// Per spec §6.4 this is a strong-reasoning stage: `gpt-5.5` with
+// `reasoningEffort: 'medium'`.
+import Type, {} from "typebox";
+import { MentionToClaimEntrySchema, STAGE_IDS, } from "./schemas.js";
+import { llmStage } from "../../../lib/pipelines/stage-helpers.js";
+import { optional } from "../../../lib/pipelines/types.js";
+export const CLAIM_CANONICALIZATION_MODEL = "gpt-5.5";
+export const CLAIM_CANONICALIZATION_REASONING = "medium";
+export const CLAIM_CANONICALIZATION_SYSTEM_PROMPT = `You merge raw claim mentions into a single canonical set of claims for an argument-ingestion pipeline.
+
+You are given:
+- the raw input text (for full context)
+- the segmented breakdown of the text
+- the list of every claim mention extracted from those segments
+- optionally, the detected citation sources + axiom indicators
+
+Your output has two parts:
+
+1. \`canonicalClaims\` — an array of canonical claims, one entry per distinct proposition the author makes. Two mentions that assert the same proposition (even when phrased differently across the text) merge into a single canonical claim. Each canonical claim carries:
+   - \`miniId\` — assign in canonicalization order: c1, c2, c3, ...
+   - \`mentionIds\` — list of the mention ids that resolved to this claim
+   - \`type\` — one of "normal", "citation", or "axiomatic" (see below)
+   - \`suggestedSymbol\` — a short PascalCase-or-snake_case identifier summarizing the claim (e.g. "Rain_Wets_Ground", "NASA_Temp_Rise", "Socrates_Mortal"). Use letters, digits, and underscores only; start with a letter or underscore; keep under 32 characters; aim for under 20. AVOID single letters and generic names like "Claim1".
+   - the extension fields described in your output schema (title, body, url, axiom — whichever apply to the claim's \`type\`)
+
+2. \`mentionToClaim\` — an array of \`{ "mentionId": "...", "claimMiniId": "..." }\` entries, one per input mention. Every input mentionId must appear in exactly one entry; the mapping is total. (We surface this as a list rather than a map because the response schema does not allow arbitrary string keys.)
+
+## Claim types
+
+- \`"normal"\` — a primary proposition the argument argues for or from.
+- \`"citation"\` — a claim whose content is "the cited source asserts X". Use this type when one of the citation sources covers the same span(s) as the mention. Populate \`url\` (the URL if present) and \`title\` (a short human-readable label).
+- \`"axiomatic"\` — a claim invoked as self-evident truth. Use this type when an axiom indicator (e.g. "by definition") covers or precedes the mention. Populate \`axiom\` with the gist of the self-evident proposition.
+
+When a mention is the antecedent of "according to X, P", split it into two claims: a citation-typed claim for the source itself + a normal-typed claim for the proposition. The two are connected via a relation in a later stage, not here.
+
+## Style
+
+- Claim titles + bodies are written in third-person, present-tense, active voice.
+- Titles are short (≤ 50 characters); bodies fill in the detail.
+- For citation claims, the title summarizes what the source asserts (e.g. "NASA reports temperature rise"); the URL goes in \`url\`.
+- For axiomatic claims, the \`axiom\` field captures the self-evident proposition (e.g. "A bachelor is an unmarried man by definition.").
+
+Output ONLY the schema-shaped object. No prose.`;
+function buildResponseSchema(extension) {
+    return Type.Object({
+        canonicalClaims: Type.Array(buildClaimRecordSchema(extension.claimSchema)),
+        // List-shape (not Record/map) for OpenAI strict-mode
+        // compatibility — see `MentionToClaimEntrySchema` docstring
+        // in `./schemas.ts` for the OpenAI 400 chain that motivated
+        // the shape change.
+        mentionToClaim: Type.Array(MentionToClaimEntrySchema),
+    }, { additionalProperties: false });
+}
+function buildClaimRecordSchema(claimSchema) {
+    // claimSchema is the extension's claim shape — often a
+    // discriminated union over `type`. We need to inject the
+    // canonicalizer-owned fields (miniId / mentionIds / suggestedSymbol)
+    // into each branch.
+    const canonicalFields = {
+        miniId: Type.String({
+            description: "Sequential canonicalization id (c1, c2, ...).",
+        }),
+        mentionIds: Type.Array(Type.String(), {
+            description: "Mention ids merged into this canonical claim.",
+        }),
+        suggestedSymbol: Type.String({
+            description: "Snake_case / PascalCase identifier proposal for the claim's logical variable. ≤ 32 chars; letters / digits / underscores; starts with letter or underscore.",
+        }),
+    };
+    const ext = claimSchema;
+    const anyOf = ext.anyOf;
+    if (Array.isArray(anyOf)) {
+        const branches = anyOf.map((branch) => {
+            const branchProps = branch
+                .properties;
+            if (!branchProps) {
+                throw new Error("claim-canonicalization: union extension branches must be object schemas.");
+            }
+            return Type.Object({ ...canonicalFields, ...branchProps }, { additionalProperties: false });
+        });
+        return Type.Union(branches);
+    }
+    const objProps = ext.properties;
+    if (!objProps) {
+        throw new Error("claim-canonicalization: extension claimSchema must be a Type.Object or a Type.Union of Type.Objects.");
+    }
+    return Type.Object({ ...canonicalFields, ...objProps }, { additionalProperties: false });
+}
+function buildPrompt(ctx) {
+    const input = ctx.input;
+    const mentionEnvelope = ctx.get(STAGE_IDS.claimMentionExtraction);
+    const mentions = mentionEnvelope?.mentions ?? [];
+    const citationEnvelope = ctx.get(STAGE_IDS.citationSourceDetection);
+    const citations = citationEnvelope?.sources ?? [];
+    const axiomEnvelope = ctx.get(STAGE_IDS.axiomIndicatorDetection);
+    const axioms = axiomEnvelope?.axioms ?? [];
+    const mentionLines = mentions
+        .map((m) => `  [${m.mentionId} @ ${m.segmentId}] ${JSON.stringify(m.text)}`)
+        .join("\n");
+    const citationLines = citations.length > 0
+        ? citations
+            .map((c) => `  [${c.sourceId} @ ${c.segmentIds.join(",")}] ${JSON.stringify(c.sourceString)}${c.url ? ` (url: ${c.url})` : ""}`)
+            .join("\n")
+        : "  (none)";
+    const axiomLines = axioms.length > 0
+        ? axioms
+            .map((a) => `  [${a.axiomId} @ ${a.segmentIds.join(",")}] ${JSON.stringify(a.indicator)}`)
+            .join("\n")
+        : "  (none)";
+    const markedSystem = `<!-- stage-id: ${STAGE_IDS.claimCanonicalization} -->\n${CLAIM_CANONICALIZATION_SYSTEM_PROMPT}`;
+    const user = `Input text:\n\n${input.text}\n\nClaim mentions:\n${mentionLines}\n\nDetected citation sources:\n${citationLines}\n\nDetected axiom indicators:\n${axiomLines}\n\nProduce the canonicalClaims + mentionToClaim object.`;
+    return { system: markedSystem, user };
+}
+/**
+ * Builds the `claim-canonicalization` stage for the supplied
+ * extension. The stage's `outputSchema` carries the extension's
+ * per-claim fields, so the LLM's structured-output schema matches the
+ * extension's claim shape (e.g. for `basics`: a discriminated union
+ * over `type`).
+ */
+export function createClaimCanonicalizationStage(extension) {
+    return llmStage({
+        id: STAGE_IDS.claimCanonicalization,
+        dependsOn: [
+            STAGE_IDS.claimMentionExtraction,
+            optional(STAGE_IDS.citationSourceDetection),
+            optional(STAGE_IDS.axiomIndicatorDetection),
+        ],
+        outputSchema: buildResponseSchema(extension),
+        model: CLAIM_CANONICALIZATION_MODEL,
+        reasoningEffort: CLAIM_CANONICALIZATION_REASONING,
+        buildPrompt,
+    });
+}
+//# sourceMappingURL=claim-canonicalization.js.map

package/dist/extensions/argument-ingestion/stages/claim-canonicalization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-canonicalization.js","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-canonicalization.ts"],"names":[],"mappings":"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"}

package/dist/extensions/argument-ingestion/stages/claim-mention-extraction.d.ts

@@ -0,0 +1,6 @@
+import { type TClaimMentionExtractionOutput } from "./schemas.js";
+import type { TStage } from "../../../lib/pipelines/types.js";
+export declare const CLAIM_MENTION_EXTRACTION_MODEL = "gpt-5.4";
+export declare const CLAIM_MENTION_EXTRACTION_SYSTEM_PROMPT = "You extract textual \"claim mentions\" from segments of an argument. A mention is any contiguous span of text that asserts a proposition the author is making \u2014 a sentence-or-clause-sized chunk that a reader would read as a single assertion.\n\nReturn an object with a single key `mentions` whose value is the array of extracted mentions. For each mention emit:\n- a fresh \"mentionId\" (m1, m2, ...; unique across all segments)\n- the \"segmentId\" the mention belongs to\n- the verbatim \"text\" of the mention (copy from the input \u2014 do not rewrite)\n- the character \"span\" (an object with \"start\" inclusive, \"end\" exclusive) relative to the SEGMENT'S TEXT (not the original input)\n\nA single segment can produce multiple mentions when it asserts multiple things. Most segments produce one mention. Do NOT deduplicate \u2014 if the same proposition is reasserted in a later segment, emit it as a separate mention there too. Do NOT classify the mention. Do NOT include connectives, hedges, or discourse markers in the span when they are not part of the asserted proposition.\n\nIf a segment is purely a discourse marker (e.g., \"Therefore,\" or \"Moreover,\"), emit no mention for it. If there are no mentions at all, return `{ \"mentions\": [] }`.";
+export declare const claimMentionExtractionStage: TStage<TClaimMentionExtractionOutput>;
+//# sourceMappingURL=claim-mention-extraction.d.ts.map

package/dist/extensions/argument-ingestion/stages/claim-mention-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-mention-extraction.d.ts","sourceRoot":"","sources":["../../../../src/extensions/argument-ingestion/stages/claim-mention-extraction.ts"],"names":[],"mappings":"AAOA,OAAO,EAGH,KAAK,6BAA6B,EAErC,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,iCAAiC,CAAA;AAE5E,eAAO,MAAM,8BAA8B,YAAY,CAAA;AAEvD,eAAO,MAAM,sCAAsC,svCAUoH,CAAA;AAavK,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,6BAA6B,CAOxE,CAAA"}