@proposit/proposit-core 0.8.9

package/dist/lib/parsing/prompt-builder.js

@@ -0,0 +1,229 @@
+/**
+ * Core property keys for each sub-schema in the parsed argument response.
+ * Used to distinguish extension fields from built-in fields.
+ */
+const CORE_CLAIM_KEYS = new Set(["miniId", "role", "sourceMiniIds"]);
+const CORE_VARIABLE_KEYS = new Set(["miniId", "symbol", "claimMiniId"]);
+const CORE_SOURCE_KEYS = new Set(["miniId", "text"]);
+const CORE_PREMISE_KEYS = new Set(["miniId", "formula"]);
+const CORE_ARGUMENT_KEYS = new Set([
+    "claims",
+    "variables",
+    "sources",
+    "premises",
+    "conclusionPremiseMiniId",
+]);
+const CORE_RESPONSE_KEYS = new Set([
+    "argument",
+    "uncategorizedText",
+    "selectionRationale",
+    "failureText",
+]);
+const CORE_PROMPT = `You are an expert argument analyst specializing in propositional logic. Your task is to analyze text and extract a structured propositional argument from it.
+
+## Task
+
+Given input text, identify:
+1. The distinct claims (propositions) being made
+2. Assign a variable (a short symbolic name) to each claim, one variable per claim
+3. Write logical formula strings connecting those variables into premises
+4. Identify which premise is the conclusion
+
+## Formula Syntax
+
+Formulas use infix notation with the following operators:
+
+- **and**: logical conjunction (A and B)
+- **or**: logical disjunction (A or B)
+- **not**: logical negation (not A)
+- **implies**: logical implication (A implies B)
+- **iff**: logical biconditional (A iff B)
+- **parentheses**: for grouping sub-expressions, e.g. (A or B) and C
+
+### Root-Only Operators
+
+The operators **implies** and **iff** must appear ONLY at the root level of a formula. They cannot be nested inside other operators. For example:
+- Valid: "A implies B"
+- Valid: "A and B"
+- Invalid: "(A implies B) and C" — implies is nested, not at root
+
+If you need to express a nested conditional, introduce an intermediate claim and a separate premise.
+
+### Variable Declaration Rule
+
+**Every symbol that appears in any premise formula MUST have a corresponding entry in the \`variables\` array, and every variable MUST reference a claim in the \`claims\` array.** If your argument requires intermediate reasoning steps — for example, when chaining implications across premises — you must declare a claim and variable for each intermediate proposition. A formula that references an undeclared symbol will be rejected and the premise will be dropped.
+
+## Response Structure
+
+Your response must conform to the provided JSON schema. Key fields:
+
+- **argument**: The parsed argument object, or null if the text cannot be parsed as an argument
+- **uncategorizedText**: Any portions of the input text that do not fit into the argument structure, or null
+- **selectionRationale**: If the text contains multiple potential arguments, explain why you chose the one you did, or null
+- **failureText**: If the argument cannot be parsed, explain why here, or null
+
+## Edge Cases
+
+- If the input text contains multiple distinct arguments, select the strongest or most complete one and explain your choice in selectionRationale.
+- If the input text cannot be reasonably interpreted as a propositional argument, set argument to null and provide an explanation in failureText.
+- If portions of the text are tangential or do not contribute to the argument, capture them in uncategorizedText.
+
+## Variable Symbols
+
+Each variable symbol should be a concise PascalCase summary of the claim it represents — short enough to scan at a glance, but specific enough to distinguish from other variables. Examples:
+
+| Claim | Good symbol | Bad symbol |
+|---|---|---|
+| "The GDP grew an average of 4% every year for the past decade" | GDP_Growth | G |
+| "Unrestricted free speech leads to the spread of misinformation" | FreeSpeech_Misinformation | Variable1 |
+| "Increased funding reduces classroom overcrowding" | Funding_Reduces_Overcrowding | FundingEffect |
+
+Use underscores to separate distinct concepts within a symbol when needed for clarity. Avoid single letters, numeric suffixes, or generic names like "Premise1".
+
+Abbreviations are encouraged to keep symbols short. Aim for under 20 characters when possible. Examples: "Gross Domestic Product growth is 4%" → GDP_Growth, "The cost of a degree at most universities has risen sharply" → Uni_Cost_Increase, "Regulatory intervention is necessary" → Reg_Intervention.
+
+## Writing Style
+
+When formulating claims, write in third person, present tense, active voice. Each claim should be a clear, standalone declarative sentence.
+
+## Sources (External Citations)
+
+Sources are **external citations or references** that support a claim — books, articles, datasets, URLs, etc. They are NOT other claims. Logical relationships between claims are expressed through variables, formulas, and premises.
+
+Each source has a miniId (e.g., "s1") and a text description of the external reference.
+
+A claim's \`sourceMiniIds\` array links that claim to its supporting **sources** (external citations). It must contain only source miniIds (e.g., \`["s1", "s2"]\`). **Never put claim miniIds (c1, c2, …) in sourceMiniIds** — that is a common mistake. If claim A depends on claim B, express that dependency through a premise formula, not through sourceMiniIds.
+
+## MiniId Conventions
+
+Each entity type uses a distinct prefix for its miniId to avoid cross-reference confusion:
+
+- Claims: \`c1\`, \`c2\`, \`c3\`, ...
+- Sources: \`s1\`, \`s2\`, \`s3\`, ...
+- Variables: \`v1\`, \`v2\`, \`v3\`, ...
+- Premises: \`p1\`, \`p2\`, \`p3\`, ...
+
+Always use the correct prefix when referencing entities. Cross-type references are strict:
+- \`sourceMiniIds\` on a claim → only \`s\`-prefixed miniIds (sources)
+- \`claimMiniId\` on a variable → only \`c\`-prefixed miniIds (claims)
+- \`conclusionPremiseMiniId\` → only \`p\`-prefixed miniIds (premises)
+
+If the input text has no external citations, leave \`sourceMiniIds\` as an empty array \`[]\` and the \`sources\` array empty.
+
+## Self-Check
+
+Before finalizing your response, verify:
+1. Every symbol that appears in any premise formula is declared in the \`variables\` array
+2. Every variable's \`claimMiniId\` references an existing claim in the \`claims\` array
+3. The \`conclusionPremiseMiniId\` references an existing premise in the \`premises\` array
+4. No \`implies\` or \`iff\` operator is nested inside another operator in any formula
+5. \`sourceMiniIds\` on claims contain only \`s\`-prefixed miniIds, never \`c\`-prefixed`;
+/**
+ * Unwrap a Nullable union (anyOf with null) to get the inner schema.
+ */
+function unwrapNullable(schema) {
+    if (schema.anyOf) {
+        const nonNull = schema.anyOf.find((s) => !(s.type === "null" || s.type === undefined));
+        if (nonNull)
+            return nonNull;
+    }
+    return schema;
+}
+/**
+ * Find extension fields in an object schema by comparing against known core keys.
+ */
+function findExtensions(schema, coreKeys, entityName) {
+    if (!schema?.properties)
+        return [];
+    const extensions = [];
+    for (const [key, fieldSchema] of Object.entries(schema.properties)) {
+        if (coreKeys.has(key))
+            continue;
+        const unwrapped = unwrapNullable(fieldSchema);
+        extensions.push({
+            entity: entityName,
+            field: key,
+            description: unwrapped.description,
+            minLength: unwrapped.minLength,
+            maxLength: unwrapped.maxLength,
+        });
+    }
+    return extensions;
+}
+/**
+ * Walk the response schema to discover all extension fields.
+ */
+function discoverExtensionFields(responseSchema) {
+    const schema = responseSchema;
+    const extensions = [];
+    // Response-level extensions
+    extensions.push(...findExtensions(schema, CORE_RESPONSE_KEYS, "response"));
+    // Argument-level: response.argument is Nullable(ArgumentSchema)
+    const argumentField = schema.properties?.argument;
+    if (!argumentField)
+        return extensions;
+    const argumentSchema = unwrapNullable(argumentField);
+    extensions.push(...findExtensions(argumentSchema, CORE_ARGUMENT_KEYS, "argument"));
+    // Claims: argument.claims is Array(ClaimSchema)
+    const claimsArray = argumentSchema.properties?.claims;
+    if (claimsArray?.items) {
+        extensions.push(...findExtensions(claimsArray.items, CORE_CLAIM_KEYS, "claim"));
+    }
+    // Variables: argument.variables is Array(VariableSchema)
+    const variablesArray = argumentSchema.properties?.variables;
+    if (variablesArray?.items) {
+        extensions.push(...findExtensions(variablesArray.items, CORE_VARIABLE_KEYS, "variable"));
+    }
+    // Sources: argument.sources is Array(SourceSchema)
+    const sourcesArray = argumentSchema.properties?.sources;
+    if (sourcesArray?.items) {
+        extensions.push(...findExtensions(sourcesArray.items, CORE_SOURCE_KEYS, "source"));
+    }
+    // Premises: argument.premises is Array(PremiseSchema)
+    const premisesArray = argumentSchema.properties?.premises;
+    if (premisesArray?.items) {
+        extensions.push(...findExtensions(premisesArray.items, CORE_PREMISE_KEYS, "premise"));
+    }
+    return extensions;
+}
+/**
+ * Format extension fields into instruction text.
+ */
+function formatExtensionInstructions(fields) {
+    if (fields.length === 0)
+        return "";
+    const lines = ["\n\n## Extension Fields\n"];
+    for (const field of fields) {
+        const constraints = [];
+        if (field.description) {
+            constraints.push(field.description);
+        }
+        if (field.minLength !== undefined) {
+            constraints.push(`minLength: ${field.minLength}`);
+        }
+        if (field.maxLength !== undefined) {
+            constraints.push(`maxLength: ${field.maxLength}`);
+        }
+        const constraintStr = constraints.length > 0 ? ` — ${constraints.join("; ")}` : "";
+        lines.push(`- **${field.entity}.${field.field}**${constraintStr}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Build the system prompt for LLM-based argument parsing.
+ *
+ * @param responseSchema - The TypeBox response schema (core or extended)
+ * @param options - Optional configuration including custom instructions
+ * @returns The complete system prompt string
+ */
+export function buildParsingPrompt(responseSchema, options) {
+    let prompt = CORE_PROMPT;
+    const extensionFields = discoverExtensionFields(responseSchema);
+    const extensionInstructions = formatExtensionInstructions(extensionFields);
+    prompt += extensionInstructions;
+    if (options?.customInstructions) {
+        prompt += `\n\n## Additional Instructions\n\n${options.customInstructions}`;
+    }
+    return prompt;
+}
+//# sourceMappingURL=prompt-builder.js.map

package/dist/lib/parsing/prompt-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-builder.js","sourceRoot":"","sources":["../../../src/lib/parsing/prompt-builder.ts"],"names":[],"mappings":"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"}

package/dist/lib/parsing/schemata.d.ts

@@ -0,0 +1,79 @@
+import Type, { type Static, type TSchema } from "typebox";
+import type { TParsingSchemaOptions } from "./types.js";
+export declare const ParsedClaimRoleType: Type.TUnion<[Type.TLiteral<"premise">, Type.TLiteral<"conclusion">, Type.TLiteral<"intermediate">]>;
+export declare const ParsedClaimSchema: Type.TObject<{
+    miniId: Type.TString;
+    role: Type.TUnion<[Type.TLiteral<"premise">, Type.TLiteral<"conclusion">, Type.TLiteral<"intermediate">]>;
+    sourceMiniIds: Type.TArray<Type.TString>;
+}>;
+export type TParsedClaim = Static<typeof ParsedClaimSchema>;
+export declare const ParsedVariableSchema: Type.TObject<{
+    miniId: Type.TString;
+    symbol: Type.TString;
+    claimMiniId: Type.TString;
+}>;
+export type TParsedVariable = Static<typeof ParsedVariableSchema>;
+export declare const ParsedSourceSchema: Type.TObject<{
+    miniId: Type.TString;
+    text: Type.TString;
+}>;
+export type TParsedSource = Static<typeof ParsedSourceSchema>;
+export declare const ParsedPremiseSchema: Type.TObject<{
+    miniId: Type.TString;
+    formula: Type.TString;
+}>;
+export type TParsedPremise = Static<typeof ParsedPremiseSchema>;
+export declare const ParsedArgumentSchema: Type.TObject<{
+    claims: Type.TArray<Type.TObject<{
+        miniId: Type.TString;
+        role: Type.TUnion<[Type.TLiteral<"premise">, Type.TLiteral<"conclusion">, Type.TLiteral<"intermediate">]>;
+        sourceMiniIds: Type.TArray<Type.TString>;
+    }>>;
+    variables: Type.TArray<Type.TObject<{
+        miniId: Type.TString;
+        symbol: Type.TString;
+        claimMiniId: Type.TString;
+    }>>;
+    sources: Type.TArray<Type.TObject<{
+        miniId: Type.TString;
+        text: Type.TString;
+    }>>;
+    premises: Type.TArray<Type.TObject<{
+        miniId: Type.TString;
+        formula: Type.TString;
+    }>>;
+    conclusionPremiseMiniId: Type.TString;
+}>;
+export type TParsedArgument = Static<typeof ParsedArgumentSchema>;
+export declare const ParsedArgumentResponseSchema: Type.TObject<{
+    argument: Type.TUnion<[Type.TObject<{
+        claims: Type.TArray<Type.TObject<{
+            miniId: Type.TString;
+            role: Type.TUnion<[Type.TLiteral<"premise">, Type.TLiteral<"conclusion">, Type.TLiteral<"intermediate">]>;
+            sourceMiniIds: Type.TArray<Type.TString>;
+        }>>;
+        variables: Type.TArray<Type.TObject<{
+            miniId: Type.TString;
+            symbol: Type.TString;
+            claimMiniId: Type.TString;
+        }>>;
+        sources: Type.TArray<Type.TObject<{
+            miniId: Type.TString;
+            text: Type.TString;
+        }>>;
+        premises: Type.TArray<Type.TObject<{
+            miniId: Type.TString;
+            formula: Type.TString;
+        }>>;
+        conclusionPremiseMiniId: Type.TString;
+    }>, Type.TNull]>;
+    uncategorizedText: Type.TUnion<[Type.TString, Type.TNull]>;
+    selectionRationale: Type.TUnion<[Type.TString, Type.TNull]>;
+    failureText: Type.TUnion<[Type.TString, Type.TNull]>;
+}>;
+export type TParsedArgumentResponse = Static<typeof ParsedArgumentResponseSchema>;
+/** Builds a composite response schema by merging optional per-entity schema extensions into the base parsing schemata. */
+export declare function buildParsingResponseSchema(options?: TParsingSchemaOptions): TSchema;
+/** Returns a plain JSON-serializable copy of the given schema (defaults to {@link ParsedArgumentResponseSchema}). */
+export declare function getParsingResponseSchema(schema?: TSchema): Record<string, unknown>;
+//# sourceMappingURL=schemata.d.ts.map

package/dist/lib/parsing/schemata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemata.d.ts","sourceRoot":"","sources":["../../../src/lib/parsing/schemata.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAgB,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAEvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEvD,eAAO,MAAM,mBAAmB,qGAI9B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;EAU7B,CAAA;AACD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,oBAAoB;;;;EAOhC,CAAA;AACD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,kBAAkB;;;EAM9B,CAAA;AACD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;EAM/B,CAAA;AACD,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;EAShC,CAAA;AACD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAA;AACD,MAAM,MAAM,uBAAuB,GAAG,MAAM,CACxC,OAAO,4BAA4B,CACtC,CAAA;AASD,0HAA0H;AAC1H,wBAAgB,0BAA0B,CACtC,OAAO,CAAC,EAAE,qBAAqB,GAChC,OAAO,CAgET;AAED,qHAAqH;AACrH,wBAAgB,wBAAwB,CACpC,MAAM,CAAC,EAAE,OAAO,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGzB"}

package/dist/lib/parsing/schemata.js

@@ -0,0 +1,92 @@
+import Type, {} from "typebox";
+import { Nullable } from "../schemata/shared.js";
+export const ParsedClaimRoleType = Type.Union([
+    Type.Literal("premise"),
+    Type.Literal("conclusion"),
+    Type.Literal("intermediate"),
+]);
+export const ParsedClaimSchema = Type.Object({
+    miniId: Type.String(),
+    role: ParsedClaimRoleType,
+    sourceMiniIds: Type.Array(Type.String(), {
+        description: "MiniIds of external sources (citations/references from the sources array, e.g. s1, s2). Must NOT contain claim miniIds — logical dependencies between claims are expressed through premises and formulas, not here.",
+    }),
+}, { additionalProperties: true });
+export const ParsedVariableSchema = Type.Object({
+    miniId: Type.String(),
+    symbol: Type.String(),
+    claimMiniId: Type.String(),
+}, { additionalProperties: true });
+export const ParsedSourceSchema = Type.Object({
+    miniId: Type.String(),
+    text: Type.String(),
+}, { additionalProperties: true });
+export const ParsedPremiseSchema = Type.Object({
+    miniId: Type.String(),
+    formula: Type.String(),
+}, { additionalProperties: true });
+export const ParsedArgumentSchema = Type.Object({
+    claims: Type.Array(ParsedClaimSchema, { minItems: 1 }),
+    variables: Type.Array(ParsedVariableSchema, { minItems: 1 }),
+    sources: Type.Array(ParsedSourceSchema),
+    premises: Type.Array(ParsedPremiseSchema, { minItems: 1 }),
+    conclusionPremiseMiniId: Type.String(),
+}, { additionalProperties: true });
+export const ParsedArgumentResponseSchema = Type.Object({
+    argument: Nullable(ParsedArgumentSchema),
+    uncategorizedText: Nullable(Type.String()),
+    selectionRationale: Nullable(Type.String()),
+    failureText: Nullable(Type.String()),
+}, { additionalProperties: true });
+function mergeObjectSchemas(base, extension) {
+    return Type.Object({ ...base.properties, ...extension.properties }, { additionalProperties: true });
+}
+/** Builds a composite response schema by merging optional per-entity schema extensions into the base parsing schemata. */
+export function buildParsingResponseSchema(options) {
+    if (!options)
+        return ParsedArgumentResponseSchema;
+    const claimSch = options.claimSchema
+        ? mergeObjectSchemas(ParsedClaimSchema, options.claimSchema)
+        : ParsedClaimSchema;
+    const variableSch = options.variableSchema
+        ? mergeObjectSchemas(ParsedVariableSchema, options.variableSchema)
+        : ParsedVariableSchema;
+    const sourceSch = options.sourceSchema
+        ? mergeObjectSchemas(ParsedSourceSchema, options.sourceSchema)
+        : ParsedSourceSchema;
+    const premiseSch = options.premiseSchema
+        ? mergeObjectSchemas(ParsedPremiseSchema, options.premiseSchema)
+        : ParsedPremiseSchema;
+    const baseArgProps = {
+        claims: Type.Array(claimSch, { minItems: 1 }),
+        variables: Type.Array(variableSch, { minItems: 1 }),
+        sources: Type.Array(sourceSch),
+        premises: Type.Array(premiseSch, { minItems: 1 }),
+        conclusionPremiseMiniId: Type.String(),
+    };
+    const argSch = options.parsedArgumentSchema
+        ? Type.Object({
+            ...baseArgProps,
+            ...options.parsedArgumentSchema.properties,
+        }, { additionalProperties: true })
+        : Type.Object(baseArgProps, { additionalProperties: true });
+    const baseResponseProps = {
+        argument: Nullable(argSch),
+        uncategorizedText: Nullable(Type.String()),
+        selectionRationale: Nullable(Type.String()),
+        failureText: Nullable(Type.String()),
+    };
+    const responseSch = options.responseSchema
+        ? Type.Object({
+            ...baseResponseProps,
+            ...options.responseSchema.properties,
+        }, { additionalProperties: true })
+        : Type.Object(baseResponseProps, { additionalProperties: true });
+    return responseSch;
+}
+/** Returns a plain JSON-serializable copy of the given schema (defaults to {@link ParsedArgumentResponseSchema}). */
+export function getParsingResponseSchema(schema) {
+    const target = schema ?? ParsedArgumentResponseSchema;
+    return JSON.parse(JSON.stringify(target));
+}
+//# sourceMappingURL=schemata.js.map

package/dist/lib/parsing/schemata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemata.js","sourceRoot":"","sources":["../../../src/lib/parsing/schemata.ts"],"names":[],"mappings":"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"}

package/dist/lib/parsing/types.d.ts

@@ -0,0 +1,24 @@
+import type { TSchema } from "typebox";
+export type TPromptOptions = {
+    customInstructions?: string;
+};
+export type TParsingSchemaOptions = {
+    claimSchema?: TSchema;
+    sourceSchema?: TSchema;
+    variableSchema?: TSchema;
+    premiseSchema?: TSchema;
+    parsedArgumentSchema?: TSchema;
+    responseSchema?: TSchema;
+};
+export type TParserWarningCode = "UNRESOLVED_SOURCE_MINIID" | "UNRESOLVED_CLAIM_MINIID" | "UNRESOLVED_CONCLUSION_MINIID" | "UNDECLARED_VARIABLE_SYMBOL" | "FORMULA_PARSE_ERROR" | "FORMULA_STRUCTURE_ERROR";
+export type TParserWarning = {
+    code: TParserWarningCode;
+    message: string;
+    context: Record<string, string>;
+};
+export type TParserBuildOptions = {
+    strict?: boolean;
+    /** UUID generator for new entity IDs. Defaults to `globalThis.crypto.randomUUID()`. */
+    generateId?: () => string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/parsing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/parsing/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,MAAM,MAAM,cAAc,GAAG;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAChC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,kBAAkB,GACxB,0BAA0B,GAC1B,yBAAyB,GACzB,8BAA8B,GAC9B,4BAA4B,GAC5B,qBAAqB,GACrB,yBAAyB,CAAA;AAE/B,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,kBAAkB,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uFAAuF;IACvF,UAAU,CAAC,EAAE,MAAM,MAAM,CAAA;CAC5B,CAAA"}

package/dist/lib/parsing/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/parsing/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/parsing/types.ts"],"names":[],"mappings":""}

package/dist/lib/schemata/analysis.d.ts

@@ -0,0 +1,9 @@
+import Type, { type Static } from "typebox";
+export declare const CoreAnalysisFileSchema: Type.TObject<{
+    argumentId: Type.TString;
+    argumentVersion: Type.TNumber;
+    assignments: Type.TRecord<"^.*$", Type.TUnion<[Type.TBoolean, Type.TNull]>>;
+    operatorAssignments: Type.TRecord<"^.*$", Type.TUnion<[Type.TLiteral<"accepted">, Type.TLiteral<"rejected">]>>;
+}>;
+export type TCoreAnalysisFile = Static<typeof CoreAnalysisFileSchema>;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/lib/schemata/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../../src/lib/schemata/analysis.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAG3C,eAAO,MAAM,sBAAsB;;;;;EAkBjC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/lib/schemata/analysis.js

@@ -0,0 +1,13 @@
+import Type, {} from "typebox";
+import { UUID } from "./shared.js";
+export const CoreAnalysisFileSchema = Type.Object({
+    argumentId: UUID,
+    argumentVersion: Type.Number(),
+    assignments: Type.Record(Type.String(), Type.Union([Type.Boolean(), Type.Null()]), {
+        description: "Variable symbol → true/false/null (unset).",
+    }),
+    operatorAssignments: Type.Record(Type.String(), Type.Union([Type.Literal("accepted"), Type.Literal("rejected")]), {
+        description: "Operator expression ID → accepted/rejected. Unset operators evaluate normally.",
+    }),
+});
+//# sourceMappingURL=analysis.js.map

package/dist/lib/schemata/analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.js","sourceRoot":"","sources":["../../../src/lib/schemata/analysis.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAe,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAElC,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC,MAAM,CAAC;IAC9C,UAAU,EAAE,IAAI;IAChB,eAAe,EAAE,IAAI,CAAC,MAAM,EAAE;IAC9B,WAAW,EAAE,IAAI,CAAC,MAAM,CACpB,IAAI,CAAC,MAAM,EAAE,EACb,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,EACzC;QACI,WAAW,EAAE,4CAA4C;KAC5D,CACJ;IACD,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAC5B,IAAI,CAAC,MAAM,EAAE,EACb,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAChE;QACI,WAAW,EACP,gFAAgF;KACvF,CACJ;CACJ,CAAC,CAAA"}

package/dist/lib/schemata/argument.d.ts

@@ -0,0 +1,14 @@
+import Type, { type Static } from "typebox";
+export declare const CoreArgumentSchema: Type.TObject<{
+    id: Type.TString;
+    version: Type.TNumber;
+    checksum: Type.TString;
+    descendantChecksum: Type.TUnion<[Type.TString, Type.TNull]>;
+    combinedChecksum: Type.TString;
+}>;
+export type TCoreArgument = Static<typeof CoreArgumentSchema>;
+export declare const CoreArgumentRoleStateSchema: Type.TObject<{
+    conclusionPremiseId: Type.TOptional<Type.TString>;
+}>;
+export type TCoreArgumentRoleState = Static<typeof CoreArgumentRoleStateSchema>;
+//# sourceMappingURL=argument.d.ts.map

package/dist/lib/schemata/argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../src/lib/schemata/argument.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAG3C,eAAO,MAAM,kBAAkB;;;;;;EAoB9B,CAAA;AACD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,2BAA2B;;EAQvC,CAAA;AACD,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/lib/schemata/argument.js

@@ -0,0 +1,24 @@
+import Type, {} from "typebox";
+import { Nullable, UUID } from "./shared.js";
+export const CoreArgumentSchema = Type.Object({
+    id: UUID,
+    version: Type.Number(),
+    checksum: Type.String({
+        description: "Argument-level checksum for sync detection.",
+    }),
+    descendantChecksum: Nullable(Type.String(), {
+        description: "Checksum derived from premises and variables collections. Null if argument has no descendants.",
+    }),
+    combinedChecksum: Type.String({
+        description: "Hash of checksum + descendantChecksum. Equals checksum when descendantChecksum is null.",
+    }),
+}, {
+    additionalProperties: true,
+    description: "Core argument identity: ID and version number.",
+});
+export const CoreArgumentRoleStateSchema = Type.Object({
+    conclusionPremiseId: Type.Optional(UUID),
+}, {
+    description: "Tracks which premise serves as the conclusion. Supporting premises are derived from expression type.",
+});
+//# sourceMappingURL=argument.js.map

package/dist/lib/schemata/argument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.js","sourceRoot":"","sources":["../../../src/lib/schemata/argument.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAe,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAE5C,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC,MAAM,CACzC;IACI,EAAE,EAAE,IAAI;IACR,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE;IACtB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC;QAClB,WAAW,EAAE,6CAA6C;KAC7D,CAAC;IACF,kBAAkB,EAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE;QACxC,WAAW,EACP,gGAAgG;KACvG,CAAC;IACF,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC;QAC1B,WAAW,EACP,yFAAyF;KAChG,CAAC;CACL,EACD;IACI,oBAAoB,EAAE,IAAI;IAC1B,WAAW,EAAE,gDAAgD;CAChE,CACJ,CAAA;AAGD,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC,MAAM,CAClD;IACI,mBAAmB,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;CAC3C,EACD;IACI,WAAW,EACP,sGAAsG;CAC7G,CACJ,CAAA"}

package/dist/lib/schemata/claim.d.ts

@@ -0,0 +1,9 @@
+import Type, { type Static } from "typebox";
+export declare const CoreClaimSchema: Type.TObject<{
+    id: Type.TString;
+    version: Type.TNumber;
+    frozen: Type.TBoolean;
+    checksum: Type.TString;
+}>;
+export type TCoreClaim = Static<typeof CoreClaimSchema>;
+//# sourceMappingURL=claim.d.ts.map

package/dist/lib/schemata/claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../../src/lib/schemata/claim.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAG3C,eAAO,MAAM,eAAe;;;;;EAmB3B,CAAA;AACD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/lib/schemata/claim.js

@@ -0,0 +1,18 @@
+import Type, {} from "typebox";
+import { UUID } from "./shared.js";
+export const CoreClaimSchema = Type.Object({
+    id: UUID,
+    version: Type.Number({
+        description: "Claim version number. Starts at 0.",
+    }),
+    frozen: Type.Boolean({
+        description: "Whether this version is frozen (immutable). Frozen versions cannot be updated.",
+    }),
+    checksum: Type.String({
+        description: "Entity-level checksum for sync detection.",
+    }),
+}, {
+    additionalProperties: true,
+    description: "A global claim representing propositional content. Variables reference claims by ID and version.",
+});
+//# sourceMappingURL=claim.js.map

package/dist/lib/schemata/claim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.js","sourceRoot":"","sources":["../../../src/lib/schemata/claim.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAe,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAElC,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,CAAC,MAAM,CACtC;IACI,EAAE,EAAE,IAAI;IACR,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC;QACjB,WAAW,EAAE,oCAAoC;KACpD,CAAC;IACF,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC;QACjB,WAAW,EACP,gFAAgF;KACvF,CAAC;IACF,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC;QAClB,WAAW,EAAE,2CAA2C;KAC3D,CAAC;CACL,EACD;IACI,oBAAoB,EAAE,IAAI;IAC1B,WAAW,EACP,kGAAkG;CACzG,CACJ,CAAA"}