@llm4ts/shell 2.13.0 → 2.14.0

package/kits/soap-ace/flows/lib/soap/Xml.js

@@ -406,7 +406,9 @@ export const resolveQName = (element, value) => {
 };
 // ---------------------------------------------------------------------------
 // Writing
-export const escapeText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+// A carriage return is written as a reference: a literal one would be
+// turned into a line feed by the reader's end-of-line handling.
+export const escapeText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#13;");
 export const escapeAttribute = (value) => escapeText(value).replace(/"/g, "&quot;");
 const qualifiedName = (prefix, local) => prefix === "" ? local : `${prefix}:${local}`;
 /**

package/kits/soap-ace/flows/lib/soap/Xsd.js

@@ -1,4 +1,4 @@
-import { AttributeField, ComplexTypeDef, ElementDecl, ElementField, Facets, isBuiltin, OpenQuestion, qname, SimpleTypeDef, splitClark, XsdNamespace } from "./Catalog.js";
+import { AttributeField, ComplexTypeDef, ElementDecl, ElementField, Facets, isBuiltin, ModelGroup, OpenQuestion, qname, SimpleTypeDef, splitClark, XsdNamespace } from "./Catalog.js";
 import { attribute, elements, firstChild, is, resolveQName, textOf } from "./Xml.js";
 // XSD reading in two passes. `collectSchema` reads one `xs:schema` element
 // into a collector without resolving anything across documents (imports and
@@ -13,8 +13,11 @@ export const makeSchemaCollector = () => ({
     complex: new Map(),
     simple: new Map(),
     elements: new Map(),
+    attributes: new Map(),
     questions: [],
-    namespaces: new Set()
+    namespaces: new Set(),
+    anonymous: new Set(),
+    locations: new Map()
 });
 const xs = (element, local) => is(element, XsdNamespace, local);
 const xsChildren = (element) => elements(element).filter((child) => child.name.namespace === XsdNamespace);
@@ -42,10 +45,30 @@ const parseMinOccurs = (value) => {
     const parsed = parseOccurs(value, 1);
     return parsed === "unbounded" ? 1 : parsed;
 };
+/** An XSD boolean attribute: `true` or `1`. */
+const flag = (element, name) => {
+    const value = attribute(element, name)?.trim();
+    return value === "true" || value === "1";
+};
+const facetNames = new Set([
+    "enumeration",
+    "pattern",
+    "length",
+    "minLength",
+    "maxLength",
+    "totalDigits",
+    "fractionDigits",
+    "minInclusive",
+    "maxInclusive",
+    "minExclusive",
+    "maxExclusive",
+    "whiteSpace"
+]);
 const multiply = (left, right) => left === "unbounded" || right === "unbounded" ? "unbounded" : left * right;
 class SchemaReader {
     targetNamespace;
     qualifiedElements;
+    qualifiedAttributes;
     /** A schema without targetNamespace included into one: its no-namespace refs mean the includer's. */
     chameleon;
     schema;
@@ -61,6 +84,20 @@ class SchemaReader {
         this.chameleon =
             attribute(schema, "targetNamespace") === undefined && namespaceOverride !== undefined;
         this.qualifiedElements = attribute(schema, "elementFormDefault") === "qualified";
+        this.qualifiedAttributes = attribute(schema, "attributeFormDefault") === "qualified";
+    }
+    /**
+     * A name for an anonymous type at `path` (`~op/x`). A global element and
+     * a named type may share a local name, so a taken path gets a `#n` suffix.
+     */
+    anonymousName(path) {
+        const base = `~${path.replace(/^~/, "")}`;
+        let name = qname(this.targetNamespace, base);
+        for (let n = 2; this.into.anonymous.has(name); n++) {
+            name = qname(this.targetNamespace, `${base}#${n}`);
+        }
+        this.into.anonymous.add(name);
+        return name;
     }
     where(element) {
         return `${this.document}:${element.line}`;
@@ -89,7 +126,7 @@ class SchemaReader {
         const references = [];
         for (const child of xsChildren(this.schema)) {
             const name = attribute(child, "name");
-            if (xs(child, "import") || xs(child, "include")) {
+            if (xs(child, "import") || xs(child, "include") || xs(child, "redefine")) {
                 const location = attribute(child, "schemaLocation");
                 if (location !== undefined) {
                     references.push({
@@ -98,6 +135,15 @@ class SchemaReader {
                         location
                     });
                 }
+                const redefined = xsChildren(child)
+                    .filter((definition) => !xs(definition, "annotation"))
+                    .map((definition) => attribute(definition, "name") ?? "?");
+                if (xs(child, "redefine") && redefined.length > 0) {
+                    this.question("redefine", child, location ?? "?", `schema ${location ?? "?"} is included, but its redefinitions of ${redefined.join(", ")} are not applied`);
+                }
+            }
+            else if (xs(child, "attribute") && name !== undefined) {
+                this.globalAttribute(child, name);
             }
             else if (xs(child, "element") && name !== undefined) {
                 this.globalElement(child, name);
@@ -119,31 +165,47 @@ class SchemaReader {
         if (attribute(element, "substitutionGroup") !== undefined) {
             this.question("substitution-group", element, name, `element ${name} joins substitution group ${attribute(element, "substitutionGroup") ?? ""}; substitutes are not modelled`);
         }
-        if (attribute(element, "abstract") === "true") {
+        if (flag(element, "abstract")) {
             this.question("abstract", element, name, `element ${name} is abstract`);
         }
-        const type = this.elementType(element, `~${name}`);
+        const type = this.elementType(element, name);
+        const fixed = attribute(element, "fixed");
+        this.into.locations.set(elementName, this.where(element));
         this.into.elements.set(elementName, new ElementDecl({
             name: elementName,
             type,
-            nillable: attribute(element, "nillable") === "true",
+            nillable: flag(element, "nillable"),
+            ...(fixed === undefined ? {} : { fixed }),
             ...optionalDoc(documentationOf(element))
         }));
     }
+    globalAttribute(element, name) {
+        const inline = firstChild(element, XsdNamespace, "simpleType");
+        let type = this.typeRef(element, attribute(element, "type"));
+        if (type === undefined && inline !== undefined) {
+            type = this.anonymousName(`@${name}`);
+            this.simpleType(inline, type, true);
+        }
+        this.into.attributes.set(qname(this.targetNamespace, name), {
+            type: type ?? stringType,
+            fixed: attribute(element, "fixed"),
+            documentation: documentationOf(element)
+        });
+    }
     /** The type of an element: its `type=` or its inline (anonymous) type. */
-    elementType(element, anonymousLocal) {
+    elementType(element, anonymousPath) {
         const declared = this.typeRef(element, attribute(element, "type"));
         if (declared !== undefined)
             return declared;
         const inlineComplex = firstChild(element, XsdNamespace, "complexType");
         if (inlineComplex !== undefined) {
-            const name = qname(this.targetNamespace, anonymousLocal);
+            const name = this.anonymousName(anonymousPath);
             this.complexType(inlineComplex, name, true);
             return name;
         }
         const inlineSimple = firstChild(element, XsdNamespace, "simpleType");
         if (inlineSimple !== undefined) {
-            const name = qname(this.targetNamespace, anonymousLocal);
+            const name = this.anonymousName(anonymousPath);
             this.simpleType(inlineSimple, name, true);
             return name;
         }
@@ -151,48 +213,69 @@ class SchemaReader {
     }
     complexType(element, name, anonymous) {
         const local = splitClark(name).local;
-        if (attribute(element, "mixed") === "true") {
+        const complexContent = firstChild(element, XsdNamespace, "complexContent");
+        const simpleContent = firstChild(element, XsdNamespace, "simpleContent");
+        if (flag(element, "mixed") || (complexContent !== undefined && flag(complexContent, "mixed"))) {
             this.question("mixed-content", element, local, `type ${local} allows mixed text content`);
         }
-        if (attribute(element, "abstract") === "true") {
+        if (flag(element, "abstract")) {
             this.question("abstract", element, local, `type ${local} is abstract`);
         }
         let base;
+        let derivation;
         let textType;
         let content = element;
-        const complexContent = firstChild(element, XsdNamespace, "complexContent");
-        const simpleContent = firstChild(element, XsdNamespace, "simpleContent");
         if (complexContent !== undefined) {
             const extension = firstChild(complexContent, XsdNamespace, "extension");
             const restriction = firstChild(complexContent, XsdNamespace, "restriction");
             if (extension !== undefined) {
                 base = this.typeRef(extension, attribute(extension, "base"));
+                derivation = "extension";
                 content = extension;
             }
             else if (restriction !== undefined) {
                 this.question("complex-restriction", restriction, local, `type ${local} restricts ${attribute(restriction, "base") ?? "?"}; only the restated content is modelled`);
+                base = this.typeRef(restriction, attribute(restriction, "base"));
+                derivation = "restriction";
                 content = restriction;
             }
         }
         else if (simpleContent !== undefined) {
-            const derivation = firstChild(simpleContent, XsdNamespace, "extension") ??
-                firstChild(simpleContent, XsdNamespace, "restriction");
-            if (derivation !== undefined) {
+            const extension = firstChild(simpleContent, XsdNamespace, "extension");
+            const restriction = firstChild(simpleContent, XsdNamespace, "restriction");
+            const step = extension ?? restriction;
+            if (step !== undefined) {
                 // The base may be a simple type (the text's type) or a complex type
                 // with simple content (inherit its text type and attributes); which
                 // one is only known once every schema is read.
-                base = this.typeRef(derivation, attribute(derivation, "base")) ?? stringType;
+                base = this.typeRef(step, attribute(step, "base")) ?? stringType;
+                derivation = extension === undefined ? "restriction" : "extension";
                 textType = base;
-                content = derivation;
+                content = step;
+                const inline = firstChild(step, XsdNamespace, "simpleType");
+                const facets = xsChildren(step).some((child) => facetNames.has(child.name.local));
+                if (extension === undefined && (facets || inline !== undefined)) {
+                    // A restriction narrows the text: an anonymous simple type over
+                    // the base's text type (resolved in the finish pass) keeps its facets.
+                    textType = this.anonymousName(`${local}/#text`);
+                    this.simpleType(step, textType, true, base);
+                }
             }
         }
         const fields = [];
+        const groups = [];
         const attributes = [];
         let counter = 0;
         const next = () => counter++;
         for (const child of xsChildren(content)) {
             if (xs(child, "sequence") || xs(child, "all") || xs(child, "choice")) {
-                this.particle(child, local, fields, { choice: undefined, branch: undefined, optional: false, repeats: 1 }, next);
+                this.particle(child, local, fields, groups, {
+                    choice: undefined,
+                    branch: undefined,
+                    group: undefined,
+                    optional: false,
+                    repeats: 1
+                }, next);
             }
             else if (xs(child, "group")) {
                 this.question("group-ref", child, local, `type ${local} uses model group ${attribute(child, "ref") ?? "?"}; its fields are not modelled`);
@@ -203,7 +286,9 @@ class SchemaReader {
             name,
             anonymous,
             base,
+            derivation,
             fields,
+            groups,
             attributes,
             textType,
             simpleContent: simpleContent !== undefined,
@@ -211,21 +296,33 @@ class SchemaReader {
             location: this.where(element)
         });
     }
-    particle(group, owner, into, context, next) {
-        const optional = context.optional || attribute(group, "minOccurs") === "0";
-        const repeats = multiply(context.repeats, parseOccurs(attribute(group, "maxOccurs"), 1));
+    particle(group, owner, into, groups, context, next) {
+        const minOccurs = parseMinOccurs(attribute(group, "minOccurs"));
+        const maxOccurs = parseOccurs(attribute(group, "maxOccurs"), 1);
+        const optional = context.optional || minOccurs === 0;
+        const repeats = multiply(context.repeats, maxOccurs);
         const isChoice = xs(group, "choice");
         const choice = isChoice ? next() : context.choice;
+        // The exact content model: every group, with its own bounds and parent.
+        const id = groups.length;
+        groups.push(new ModelGroup({
+            id,
+            kind: isChoice ? "choice" : xs(group, "all") ? "all" : "sequence",
+            minOccurs,
+            maxOccurs,
+            ...(context.group === undefined ? {} : { parent: context.group }),
+            start: into.length
+        }));
         for (const child of xsChildren(group)) {
             // Every alternative of a choice is its own branch; inside a branch,
             // a nested sequence keeps the branch it belongs to.
             const branch = isChoice ? next() : context.branch;
-            const inner = { choice, branch, optional, repeats };
+            const inner = { choice, branch, group: id, optional, repeats };
             if (xs(child, "element")) {
                 into.push(this.localElement(child, owner, inner));
             }
             else if (xs(child, "sequence") || xs(child, "choice") || xs(child, "all")) {
-                this.particle(child, owner, into, inner, next);
+                this.particle(child, owner, into, groups, inner, next);
             }
             else if (xs(child, "any")) {
                 this.question("xsd-any", child, owner, `type ${owner} accepts any element (namespace ${attribute(child, "namespace") ?? "##any"}); its content is open`);
@@ -237,14 +334,19 @@ class SchemaReader {
     }
     localElement(element, owner, context) {
         const ref = this.typeRef(element, attribute(element, "ref"));
-        const minOccurs = context.optional ? 0 : parseMinOccurs(attribute(element, "minOccurs"));
-        const maxOccurs = multiply(parseOccurs(attribute(element, "maxOccurs"), 1), context.repeats);
+        const own = {
+            min: parseMinOccurs(attribute(element, "minOccurs")),
+            max: parseOccurs(attribute(element, "maxOccurs"), 1)
+        };
         const base = {
-            minOccurs,
-            maxOccurs,
-            nillable: attribute(element, "nillable") === "true",
+            minOccurs: context.optional ? 0 : own.min,
+            maxOccurs: multiply(own.max, context.repeats),
+            own,
+            nillable: flag(element, "nillable"),
+            fixed: attribute(element, "fixed"),
             choice: context.choice,
             branch: context.branch,
+            group: context.group ?? 0,
             documentation: documentationOf(element),
             location: this.where(element)
         };
@@ -259,26 +361,49 @@ class SchemaReader {
             ...base,
             name,
             namespace: qualified ? this.targetNamespace : "",
-            type: this.elementType(element, `~${owner.replace(/^~/, "")}/${name}`),
+            type: this.elementType(element, `${owner}/${name}`),
             ref: undefined
         };
     }
     attributes(content, owner, into) {
         for (const child of xsChildren(content)) {
             if (xs(child, "attribute")) {
-                const name = attribute(child, "name") ?? attribute(child, "ref") ?? "?";
+                const common = {
+                    use: attribute(child, "use"),
+                    fixed: attribute(child, "fixed"),
+                    documentation: documentationOf(child),
+                    location: this.where(child)
+                };
+                const ref = this.typeRef(child, attribute(child, "ref"));
+                if (ref !== undefined) {
+                    // A global attribute: its name, type and namespace are the
+                    // declaration's, looked up once every schema is read.
+                    const target = splitClark(ref);
+                    into.push({
+                        ...common,
+                        name: target.local,
+                        namespace: target.namespace === "" ? undefined : target.namespace,
+                        type: stringType,
+                        ref
+                    });
+                    continue;
+                }
+                const name = attribute(child, "name") ?? "?";
                 const inline = firstChild(child, XsdNamespace, "simpleType");
                 let type = this.typeRef(child, attribute(child, "type"));
                 if (type === undefined && inline !== undefined) {
-                    type = qname(this.targetNamespace, `~${owner.replace(/^~/, "")}/@${name}`);
+                    type = this.anonymousName(`${owner}/@${name}`);
                     this.simpleType(inline, type, true);
                 }
-                into.push(new AttributeField({
+                const form = attribute(child, "form");
+                const qualified = form === undefined ? this.qualifiedAttributes : form === "qualified";
+                into.push({
+                    ...common,
                     name,
+                    namespace: qualified && this.targetNamespace !== "" ? this.targetNamespace : undefined,
                     type: type ?? stringType,
-                    required: attribute(child, "use") === "required",
-                    ...optionalDoc(documentationOf(child))
-                }));
+                    ref: undefined
+                });
             }
             else if (xs(child, "attributeGroup")) {
                 this.question("attribute-group", child, owner, `type ${owner} uses attribute group ${attribute(child, "ref") ?? "?"}; its attributes are not modelled`);
@@ -288,24 +413,59 @@ class SchemaReader {
             }
         }
     }
-    simpleType(element, name, anonymous) {
+    /**
+     * A simple type from its `xs:simpleType` element, or (with `restrictionBase`)
+     * from a simpleContent restriction whose base is only known later.
+     */
+    simpleType(element, name, anonymous, restrictionBase) {
         const local = splitClark(name).local;
-        const restriction = firstChild(element, XsdNamespace, "restriction");
+        this.into.locations.set(name, this.where(element));
+        const restriction = restrictionBase === undefined ? firstChild(element, XsdNamespace, "restriction") : element;
+        const list = firstChild(element, XsdNamespace, "list");
+        if (restriction === undefined && list !== undefined) {
+            // A list: whitespace-separated items of the item type; length facets
+            // of a restriction over it count items.
+            const inline = firstChild(list, XsdNamespace, "simpleType");
+            let itemType = this.typeRef(list, attribute(list, "itemType"));
+            if (itemType === undefined && inline !== undefined) {
+                itemType = this.anonymousName(`${local}/#item`);
+                this.simpleType(inline, itemType, true);
+            }
+            this.into.simple.set(name, new SimpleTypeDef({
+                name,
+                anonymous,
+                base: stringType,
+                facets: new Facets({}),
+                variety: "list",
+                itemType: itemType ?? stringType,
+                ...optionalDoc(documentationOf(element))
+            }));
+            return;
+        }
         if (restriction === undefined) {
-            this.question("list-or-union", element, local, `simple type ${local} is a list or union; values are treated as strings`);
+            this.question("list-or-union", element, local, `simple type ${local} is a union; values are treated as strings`);
             this.into.simple.set(name, new SimpleTypeDef({
                 name,
                 anonymous,
                 base: stringType,
                 facets: new Facets({}),
+                variety: "union",
                 ...optionalDoc(documentationOf(element))
             }));
             return;
         }
+        // The base is `base=`, or an anonymous simple type written inside.
+        let base = this.typeRef(restriction, attribute(restriction, "base")) ?? restrictionBase;
+        const inline = firstChild(restriction, XsdNamespace, "simpleType");
+        if (inline !== undefined && (base === undefined || restrictionBase !== undefined)) {
+            const inlineName = this.anonymousName(`${local}/#base`);
+            this.simpleType(inline, inlineName, true);
+            base = inlineName;
+        }
         this.into.simple.set(name, new SimpleTypeDef({
             name,
             anonymous,
-            base: this.typeRef(restriction, attribute(restriction, "base")) ?? stringType,
+            base: base ?? stringType,
             facets: readFacets(restriction),
             ...optionalDoc(documentationOf(element))
         }));
@@ -337,6 +497,7 @@ const readFacets = (restriction) => {
     const maxLength = intFacet(restriction, "maxLength");
     const totalDigits = intFacet(restriction, "totalDigits");
     const fractionDigits = intFacet(restriction, "fractionDigits");
+    const whiteSpace = stringFacet(restriction, "whiteSpace")?.trim();
     return new Facets({
         ...(enumeration.length > 0 ? { enumeration } : {}),
         ...(pattern.length > 0 ? { pattern } : {}),
@@ -348,7 +509,10 @@ const readFacets = (restriction) => {
         ...(minInclusive === undefined ? {} : { minInclusive }),
         ...(maxInclusive === undefined ? {} : { maxInclusive }),
         ...(minExclusive === undefined ? {} : { minExclusive }),
-        ...(maxExclusive === undefined ? {} : { maxExclusive })
+        ...(maxExclusive === undefined ? {} : { maxExclusive }),
+        ...(whiteSpace === "preserve" || whiteSpace === "replace" || whiteSpace === "collapse"
+            ? { whiteSpace }
+            : {})
     });
 };
 /** Read one `xs:schema` into the collector; returns the imports/includes to follow. */
@@ -368,9 +532,10 @@ export const finishSchemas = (collector) => {
             detail: `type ${name} is not defined in any schema that was read`
         }));
     };
-    const resolveField = (field, owner, offset) => {
+    const resolveField = (field, owner, offset, groupOffset) => {
         let type = field.type ?? anyType;
         let nillable = field.nillable;
+        let fixed = field.fixed;
         if (field.ref !== undefined) {
             const target = collector.elements.get(field.ref);
             if (target === undefined) {
@@ -384,6 +549,7 @@ export const finishSchemas = (collector) => {
             else {
                 type = target.type;
                 nillable = nillable || target.nillable;
+                fixed = fixed ?? target.fixed;
             }
         }
         else if (!typeExists(collector, type)) {
@@ -398,9 +564,46 @@ export const finishSchemas = (collector) => {
             nillable,
             ...(field.choice === undefined ? {} : { choice: field.choice + offset }),
             ...(field.branch === undefined ? {} : { branch: field.branch + offset }),
+            group: field.group + groupOffset,
+            occurs: field.own,
+            ...(fixed === undefined ? {} : { fixed }),
             ...optionalDoc(field.documentation)
         });
     };
+    const resolveAttribute = (raw, owner) => {
+        if (raw.use === "prohibited")
+            return undefined;
+        let type = raw.type;
+        let fixed = raw.fixed;
+        let documentation = raw.documentation;
+        if (raw.ref !== undefined) {
+            const target = collector.attributes.get(raw.ref);
+            if (target === undefined) {
+                questions.push(new OpenQuestion({
+                    code: "unresolved-attribute",
+                    location: raw.location,
+                    subject: owner,
+                    detail: `attribute ref ${raw.ref} is not declared in any schema that was read`
+                }));
+            }
+            else {
+                type = target.type;
+                fixed = fixed ?? target.fixed;
+                documentation = documentation ?? target.documentation;
+            }
+        }
+        if (!typeExists(collector, type))
+            unresolvedType(type, raw.location, owner);
+        return new AttributeField({
+            name: raw.name,
+            ...(raw.namespace === undefined ? {} : { namespace: raw.namespace }),
+            type,
+            required: raw.use === "required",
+            ...(fixed === undefined ? {} : { fixed }),
+            ...optionalDoc(documentation)
+        });
+    };
+    const sameAttribute = (left, right) => left.name === right.name && (left.namespace ?? "") === (right.namespace ?? "");
     const flattened = new Map();
     const flatten = (raw, visiting) => {
         const done = flattened.get(raw.name);
@@ -408,6 +611,7 @@ export const finishSchemas = (collector) => {
             return done;
         const owner = splitClark(raw.name).local;
         let inheritedFields = [];
+        let inheritedGroups = [];
         let inheritedAttributes = [];
         let textType = raw.textType;
         if (raw.base !== undefined && !isBuiltin(raw.base)) {
@@ -418,33 +622,65 @@ export const finishSchemas = (collector) => {
             }
             else if (!visiting.has(raw.base)) {
                 const base = flatten(baseRaw, new Set([...visiting, raw.name]));
-                inheritedFields = base.fields;
+                // A restriction restates the content; only attributes carry over.
+                if (raw.derivation !== "restriction" || raw.simpleContent) {
+                    inheritedFields = base.fields;
+                    inheritedGroups = base.groups ?? [];
+                }
                 inheritedAttributes = base.attributes;
                 // Simple content over a complex base: the text type is the base's.
-                if (raw.simpleContent)
+                if (raw.simpleContent && raw.textType === raw.base)
                     textType = base.textType ?? stringType;
             }
         }
         // Choice and branch ids of the derived part continue after the base's,
         // so a base choice and a derived choice stay separate groups.
         const offset = inheritedFields.reduce((max, field) => Math.max(max, (field.choice ?? -1) + 1, (field.branch ?? -1) + 1), 0);
+        const groupOffset = inheritedGroups.length;
+        const fieldOffset = inheritedFields.length;
         if (textType !== undefined && !typeExists(collector, textType)) {
             unresolvedType(textType, raw.location, owner);
         }
-        for (const attributeField of raw.attributes) {
-            if (!typeExists(collector, attributeField.type)) {
-                unresolvedType(attributeField.type, raw.location, owner);
+        // Derived attributes restate (or prohibit) inherited ones of the same name.
+        const attributes = [];
+        for (const inherited of inheritedAttributes) {
+            const restated = raw.attributes.find((candidate) => sameAttribute(inherited, candidate));
+            if (restated === undefined)
+                attributes.push(inherited);
+            else {
+                const resolved = resolveAttribute(restated, owner);
+                if (resolved !== undefined)
+                    attributes.push(resolved);
             }
         }
+        for (const declared of raw.attributes) {
+            if (inheritedAttributes.some((inherited) => sameAttribute(inherited, declared)))
+                continue;
+            const resolved = resolveAttribute(declared, owner);
+            if (resolved !== undefined)
+                attributes.push(resolved);
+        }
+        const groups = [
+            ...inheritedGroups,
+            ...raw.groups.map((group) => new ModelGroup({
+                ...group,
+                id: group.id + groupOffset,
+                ...(group.parent === undefined ? {} : { parent: group.parent + groupOffset }),
+                start: group.start + fieldOffset
+            }))
+        ];
         const result = new ComplexTypeDef({
             name: raw.name,
             anonymous: raw.anonymous,
-            ...(raw.base === undefined ? {} : { base: raw.base }),
+            ...(raw.base === undefined || (raw.derivation === "restriction" && !raw.simpleContent)
+                ? {}
+                : { base: raw.base }),
             fields: [
                 ...inheritedFields,
-                ...raw.fields.map((field) => resolveField(field, owner, offset))
+                ...raw.fields.map((field) => resolveField(field, owner, offset, groupOffset))
             ],
-            attributes: [...inheritedAttributes, ...raw.attributes],
+            ...(groups.length === 0 ? {} : { groups }),
+            attributes,
             ...(textType === undefined ? {} : { textType }),
             ...optionalDoc(raw.documentation)
         });
@@ -452,15 +688,28 @@ export const finishSchemas = (collector) => {
         return result;
     };
     const complex = [...collector.complex.values()].map((raw) => flatten(raw, new Set()));
-    const simple = [...collector.simple.values()];
+    // A simpleContent restriction's text type restricts its complex base's
+    // text type, known only now.
+    const simple = [...collector.simple.values()].map((type) => {
+        const complexBase = collector.complex.get(type.base);
+        if (complexBase === undefined)
+            return type;
+        return new SimpleTypeDef({
+            ...type,
+            base: flatten(complexBase, new Set()).textType ?? stringType
+        });
+    });
     for (const type of simple) {
-        if (!typeExists(collector, type.base)) {
-            unresolvedType(type.base, "(simple type)", splitClark(type.name).local);
+        const types = [type.base, ...(type.itemType === undefined ? [] : [type.itemType])];
+        for (const name of types) {
+            if (!typeExists(collector, name)) {
+                unresolvedType(name, collector.locations.get(type.name) ?? "(simple type)", splitClark(type.name).local);
+            }
         }
     }
     for (const element of collector.elements.values()) {
         if (!typeExists(collector, element.type)) {
-            unresolvedType(element.type, "(global element)", splitClark(element.name).local);
+            unresolvedType(element.type, collector.locations.get(element.name) ?? "(global element)", splitClark(element.name).local);
         }
     }
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llm4ts/shell",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "Interactive shell and CLI for llm4ts: flow discovery, run-a-flow, and view",
   "license": "MIT",
   "type": "module",
@@ -52,9 +52,9 @@
   "dependencies": {
     "@effect/platform-node": "4.0.0-rc.115",
     "@effect/platform-node-shared": "4.0.0-rc.115",
-    "@llm4ts/flow": "2.13.0",
-    "@llm4ts/runner": "2.13.0",
-    "@llm4ts/core": "2.13.0"
+    "@llm4ts/core": "2.14.0",
+    "@llm4ts/flow": "2.14.0",
+    "@llm4ts/runner": "2.14.0"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.115"