How should you .pipe to a type constructed with or?

[fnimick]

I have the following:

const objSchema = type({
  action: "'scheduled' | 'rescheduled' | 'canceled' | 'changed'",
  id: "parse.integer",
  calendarID: "parse.integer",
  appointmentTypeID: "parse.integer",
}).or({
  action: "'order.completed'",
});
const formSchema = type("parse.formData").pipe(objSchema);

Not only does this not work, but simply calling .pipe appears to break my objSchema entirely. Using it and not the formSchema results in the following error:

ParseError: An unordered union of a type including a morph and a type with overlapping input is indeterminate:
Left: (In: FormData) => Out<{ action: "order.completed" }>
Right: (In: { action: "canceled" | "changed" | "rescheduled" | "scheduled", appointmentTypeID: (In: string /^(?:0|(?:-?[1-9]\d*))$/) => Out<unknown>, calendarID: (In: string /^(?:0|(?:-?[1-9]\d*))$/) => Out<unknown>, id: (In: string /^(?:0|(?:-?[1-9]\d*))$/) => Out<unknown> }) => Out<unknown>

Simply calling .pipe on a type constructed using .or appears to break the underlying or type entirely.

[ssalbdivad]

The error you're getting is there to warn about cases where you have morphs (in this case, parse.integer) on a type that can't be reliably distinguished from another type, leading to non-deterministic behavior.

However, these two types should be discriminatable because there is an action key that is a string literal.

The reason we're failing to discriminate this case is the string literal union. There's currently a limitation affecting this type of discriminated union:

#1010

Once this issue is resolved, your union will be correctly discriminated. I'll actually make a point as well to loosen the restrictions a bit here so any union with disjoint branches can include morphs in the next release.

[fnimick]

edit: I was totally wrong, the type being piped to is not modified.

[ssalbdivad]

Unlike input data, types are treated as totally immutable, so if there is ever a case where an internal API changes the structure of an existing type, that is a bug.

The easiest way for that type of non-determinism to creep in is caching related bugs, although even in those cases it is rare the result would be mutation and more common it just incorrect operation results.