@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Resource-B1cI8FyJ.d.mts

@@ -0,0 +1,218 @@
+import { O as Triple, _ as Quad, d as NamedNode, o as Graph, t as BlankNode, w as Subject } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as SchemaAST from "effect/SchemaAST";
+declare namespace Resource_d_exports {
+  export { DecodeOptions, Decoded, Description, DescriptionKey, EncodeOptions, InputSchema, ListKey, Property, PropertyKey, PropertyOptions, SubjectSchema, decode, decodeAll, describe, encode, list, property, schema };
+}
+/**
+ * The annotation key `property` stores a field's `Property` under.
+ *
+ * @since 0.1.0
+ * @category annotations
+ */
+declare const PropertyKey = "@thomasfosterau/effect-rdf/Resource/property";
+/**
+ * The annotation key `describe` stores a struct's `Description` under.
+ *
+ * @since 0.1.0
+ * @category annotations
+ */
+declare const DescriptionKey = "@thomasfosterau/effect-rdf/Resource/description";
+/**
+ * The annotation key `list` marks an array schema as an RDF collection with.
+ *
+ * @since 0.1.0
+ * @category annotations
+ */
+declare const ListKey = "@thomasfosterau/effect-rdf/Resource/list";
+/**
+ * How a field reads its values: the direction of its predicate and, for
+ * literals, the language tags it prefers.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PropertyOptions {
+  /**
+   * Read the subjects of `?x predicate resource` instead of the objects of
+   * `resource predicate ?x` (and write such quads).
+   */
+  readonly inverse?: boolean | undefined;
+  /**
+   * Language tags in order of preference, `''` for an untagged value. A
+   * single-valued field takes the first value whose tag matches, trying the
+   * tags in order; a multi-valued field keeps the values whose tag is listed.
+   * Tags compare case-insensitively. Overrides `DecodeOptions.languages`.
+   */
+  readonly languages?: ReadonlyArray<string> | undefined;
+}
+/**
+ * The predicate a field maps to, with its `PropertyOptions`: the value of the
+ * `PropertyKey` annotation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Property extends PropertyOptions {
+  readonly predicate: NamedNode;
+}
+/**
+ * What `describe` records about a struct: the `rdf:type` its resources carry
+ * and the field holding the resource itself.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Description {
+  /**
+   * The class every resource of this shape is an instance of: decoding
+   * requires `resource rdf:type type`, encoding writes it, and `decodeAll`
+   * finds the resources by it.
+   */
+  readonly type?: NamedNode | undefined;
+  /**
+   * The name of a field that holds the resource term itself (decoded through
+   * that field's codec, e.g. `TermCodec.namedNode` or `TermCodec.iri`). A
+   * nested value with an id encodes under it; one without becomes a fresh
+   * blank node.
+   */
+  readonly id?: string | undefined;
+}
+/**
+ * Maps a struct field to a predicate: annotates `codec` with the predicate
+ * (and `options`) without changing its type, so it composes with
+ * `Schema.optional`, `Schema.Array` and `list` on either side.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const property: <S extends Schema.Top>(predicate: NamedNode, codec: S, options?: PropertyOptions) => S["Rebuild"];
+/**
+ * Describes a struct as an RDF resource: the `rdf:type` it requires and
+ * writes, and the field (if any) holding the resource term.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const describe: (description: Description) => <S extends Schema.Top>(self: S) => S["Rebuild"];
+/**
+ * An array read from and written to an RDF collection (an `rdf:first` /
+ * `rdf:rest` list ending in `rdf:nil`) instead of repeated objects.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const list: <S extends Schema.Top>(item: S) => Schema.$Array<S>;
+/**
+ * Options for `decode`, `decodeAll` and `schema`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface DecodeOptions {
+  /** The graph to read (every graph when omitted). */
+  readonly graph?: Graph | undefined;
+  /** The default `PropertyOptions.languages` of every field. */
+  readonly languages?: ReadonlyArray<string> | undefined;
+  /** Passed to the struct's decoder (e.g. `{ errors: 'all' }`). */
+  readonly parseOptions?: SchemaAST.ParseOptions | undefined;
+}
+/**
+ * Options for `encode` and `schema`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface EncodeOptions {
+  /** The graph to write the quads into (the default graph when omitted). */
+  readonly graph?: Graph | undefined;
+  /** Passed to the struct's encoder. */
+  readonly parseOptions?: SchemaAST.ParseOptions | undefined;
+}
+/**
+ * One resource `decodeAll` found and decoded.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Decoded<A> {
+  readonly subject: Subject;
+  readonly value: A;
+}
+/**
+ * Decodes the resource `subject` of `dataset` with a struct of `property`
+ * fields: reads each field's values, checks their number against the field's
+ * cardinality, decodes nested resources recursively and runs the struct's
+ * decoder over the result.
+ *
+ * @since 0.1.0
+ * @category decoding
+ */
+declare const decode: <S extends Schema.Constraint>(schema: S) => (dataset: Dataset, subject: Subject, options?: DecodeOptions) => Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"]>;
+/**
+ * Decodes every resource whose `rdf:type` is the struct's described `type`
+ * (in `Term.Order` of the subjects). Fails on the first resource that does
+ * not decode, with the subject at the head of the issue's path; fails when
+ * the struct has no described `type`.
+ *
+ * @since 0.1.0
+ * @category decoding
+ */
+declare const decodeAll: <S extends Schema.Constraint>(schema: S) => (dataset: Dataset, options?: DecodeOptions) => Effect.Effect<ReadonlyArray<Decoded<S["Type"]>>, Schema.SchemaError, S["DecodingServices"]>;
+/**
+ * Encodes `value` as the resource `subject`: the struct's encoder turns each
+ * field into terms, written as `subject predicate term` quads (or
+ * `term predicate subject` for an `inverse` field), with an `rdf:type` quad
+ * for a described type, RDF collections for `list` fields and the quads of
+ * nested resources.
+ *
+ * @since 0.1.0
+ * @category encoding
+ */
+declare const encode: <S extends Schema.Constraint>(schema: S) => (subject: Subject, value: S["Type"], options?: EncodeOptions) => Effect.Effect<ReadonlyArray<Quad>, Schema.SchemaError, S["EncodingServices"]>;
+/**
+ * A subject term: an IRI, blank node or triple term.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const SubjectSchema: Schema.Union<readonly [Schema.declare<NamedNode>, Schema.declare<BlankNode>, Schema.declare<Triple>]>;
+/**
+ * The type `SubjectSchema` decodes to: `Term.Subject`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type SubjectSchema = typeof SubjectSchema.Type;
+/**
+ * The encoded side of `schema`: a dataset and the resource in it.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const InputSchema: Schema.Struct<{
+  readonly dataset: Schema.declare<Dataset>;
+  readonly subject: typeof SubjectSchema;
+}>;
+/**
+ * The type `InputSchema` decodes to: `{ dataset, subject }`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type InputSchema = typeof InputSchema.Type;
+/**
+ * The `Schema` form of `decode` / `encode`: decodes `{ dataset, subject }`
+ * to the struct's type, and encodes a value to the dataset of its quads with
+ * the resource as `subject` (its `describe`d id, or a fresh blank node). It
+ * composes with `Schema.decodeTo`, `Schema.decodeUnknownEffect` and the rest
+ * of the `Schema` API.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const schema: <S extends Schema.Top>(self: S, options?: DecodeOptions & EncodeOptions) => Schema.decodeTo<Schema.toType<S>, typeof InputSchema, S["DecodingServices"], S["EncodingServices"]>;
+export { list as _, EncodeOptions as a, Property as c, Resource_d_exports as d, SubjectSchema as f, encode as g, describe as h, DescriptionKey as i, PropertyKey as l, decodeAll as m, Decoded as n, InputSchema as o, decode as p, Description as r, ListKey as s, DecodeOptions as t, PropertyOptions as u, property as v, schema as y };
+//# sourceMappingURL=Resource-B1cI8FyJ.d.mts.map

package/dist/Resource-sIEeNh15.mjs

@@ -0,0 +1,374 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { G as isTerm, O as defaultGraph, T as blankNode, V as isObject, W as isSubject, b as TripleSchema, d as Quad, l as NamedNodeSchema, n as BlankNodeSchema, u as Order, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf, C as list$1, E as match, L as subjectsOf, m as fromIterable, t as DatasetSchema } from "./Dataset-BlmlcI7J.mjs";
+import { i as rdf } from "./Vocab-DceKywpq.mjs";
+import { i as normalize } from "./LanguageTag-BcOpMGZ4.mjs";
+import * as Arr from "effect/Array";
+import * as Equal from "effect/Equal";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Effect from "effect/Effect";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Record from "effect/Record";
+import * as SchemaAST from "effect/SchemaAST";
+import * as SchemaParser from "effect/SchemaParser";
+// src/Resource.ts
+/**
+* Typed records over the resources of a `Dataset`: annotate a `Schema.Struct`
+* with the predicate behind each field, then decode a subject's properties
+* into the struct's type and encode a value back to quads.
+*
+* ```ts
+* const Person = Schema.Struct({
+*   name: Resource.property(foaf('name'), TermCodec.string),
+*   nick: Schema.optional(Resource.property(foaf('nick'), TermCodec.string)),
+*   knows: Resource.property(foaf('knows'), Schema.Array(TermCodec.namedNode)),
+* }).pipe(Resource.describe({ type: foaf('Person') }))
+*
+* Resource.decode(Person)(dataset, alice) // Effect<{ name: string; nick?: string; … }, SchemaError>
+* Resource.encode(Person)(alice, value) // Effect<ReadonlyArray<Quad>, SchemaError>
+* ```
+*
+* A field's cardinality comes from its schema: a plain codec reads exactly
+* one object, `Schema.optional` / `Schema.optionalKey` at most one,
+* `Schema.Array` any number (in `Term.Order`) and `list` an RDF collection.
+* A field whose codec is a struct is a nested resource, decoded from the
+* object's own properties. Each value decodes through its field's codec (see
+* `TermCodec`), and failures are ordinary schema issues at the field's path.
+*
+* @since 0.1.0
+*/
+var Resource_exports = /* @__PURE__ */ __exportAll({
+	DescriptionKey: () => DescriptionKey,
+	InputSchema: () => InputSchema,
+	ListKey: () => ListKey,
+	PropertyKey: () => PropertyKey,
+	SubjectSchema: () => SubjectSchema,
+	decode: () => decode,
+	decodeAll: () => decodeAll,
+	describe: () => describe,
+	encode: () => encode,
+	list: () => list,
+	property: () => property,
+	schema: () => schema
+});
+/**
+* The annotation key `property` stores a field's `Property` under.
+*
+* @since 0.1.0
+* @category annotations
+*/
+const PropertyKey = "@thomasfosterau/effect-rdf/Resource/property";
+/**
+* The annotation key `describe` stores a struct's `Description` under.
+*
+* @since 0.1.0
+* @category annotations
+*/
+const DescriptionKey = "@thomasfosterau/effect-rdf/Resource/description";
+/**
+* The annotation key `list` marks an array schema as an RDF collection with.
+*
+* @since 0.1.0
+* @category annotations
+*/
+const ListKey = "@thomasfosterau/effect-rdf/Resource/list";
+/**
+* Maps a struct field to a predicate: annotates `codec` with the predicate
+* (and `options`) without changing its type, so it composes with
+* `Schema.optional`, `Schema.Array` and `list` on either side.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const property = (predicate, codec, options) => {
+	const value = {
+		...options,
+		predicate
+	};
+	return codec.annotate({ [PropertyKey]: value });
+};
+/**
+* Describes a struct as an RDF resource: the `rdf:type` it requires and
+* writes, and the field (if any) holding the resource term.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const describe = (description) => (self) => self.annotate({ [DescriptionKey]: description });
+/**
+* An array read from and written to an RDF collection (an `rdf:first` /
+* `rdf:rest` list ending in `rdf:nil`) instead of repeated objects.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const list = (item) => Schema.Array(item).annotate({ [ListKey]: true });
+const keyOf = (signature) => Predicate.isNumber(signature.name) ? Option.none() : Option.some(signature.name);
+const propertyOf = SchemaAST.resolveAt(PropertyKey);
+const descriptionOf = SchemaAST.resolveAt(DescriptionKey);
+const isList = (ast) => SchemaAST.resolveAt(ListKey)(ast) === true;
+const resolveSuspend = (ast) => SchemaAST.isSuspend(ast) ? resolveSuspend(ast.thunk()) : ast;
+const withoutUndefined = (ast) => {
+	if (!SchemaAST.isUnion(ast)) return ast;
+	const defined = Arr.filter(ast.types, (t) => !SchemaAST.isUndefined(t));
+	return defined.length === 1 && defined.length < ast.types.length ? Option.getOrElse(Arr.head(defined), () => ast) : ast;
+};
+const arrayItem = (ast) => SchemaAST.isArrays(ast) && ast.encoding === void 0 && Arr.isReadonlyArrayEmpty(ast.elements) ? Arr.head(ast.rest) : Option.none();
+const nestedStruct = (ast) => {
+	const resolved = resolveSuspend(ast);
+	return SchemaAST.isObjects(resolved) && resolved.encoding === void 0 ? Option.some(resolved) : Option.none();
+};
+const fieldOf = (signature) => Option.flatMap(keyOf(signature), (name) => fieldNamed(name, signature));
+const fieldNamed = (name, signature) => {
+	const declared = signature.type;
+	const optional = SchemaAST.isOptional(declared);
+	const inner = withoutUndefined(declared);
+	const element = arrayItem(inner);
+	const annotated = Arr.getSomes([
+		Option.fromUndefinedOr(propertyOf(declared)),
+		Option.fromUndefinedOr(propertyOf(inner)),
+		Option.flatMap(element, (e) => Option.fromUndefinedOr(propertyOf(e)))
+	]);
+	return Option.map(Arr.head(annotated), (found) => Option.match(element, {
+		onNone: () => ({
+			name,
+			property: found,
+			cardinality: "one",
+			optional,
+			item: inner
+		}),
+		onSome: (item) => ({
+			name,
+			property: found,
+			cardinality: isList(inner) ? "list" : "many",
+			optional,
+			item
+		})
+	}));
+};
+const expectStruct = (ast) => Effect.mapError(Effect.fromOption(nestedStruct(ast)), () => new SchemaIssue.InvalidValue({ message: "Expected a struct schema (Schema.Struct) to map a resource to" }));
+const describedType = (ast) => Option.fromUndefinedOr(descriptionOf(ast)?.type);
+const describedId = (ast) => Option.fromUndefinedOr(descriptionOf(ast)?.id);
+const languageOf = (term) => isLiteral(term) ? normalize(term.language) : "";
+const hasLanguage = (tag) => (term) => languageOf(term) === normalize(tag);
+const valuesOf = (context, subject, field) => {
+	const { predicate, inverse } = field.property;
+	const terms = inverse === true ? subjectsOf(context.dataset, predicate, subject, context.options.graph) : objectsOf(context.dataset, subject, predicate, context.options.graph);
+	const sorted = Arr.sort(terms, Order);
+	const languages = field.property.languages ?? context.options.languages;
+	if (languages === void 0) return sorted;
+	if (field.cardinality === "one") return Arr.fromOption(Arr.findFirst(languages, (tag) => Arr.findFirst(sorted, hasLanguage(tag))));
+	return Arr.dedupe(Arr.flatMap(languages, (tag) => Arr.filter(sorted, hasLanguage(tag))));
+};
+const describePredicate = (field) => field.property.inverse === true ? `^${field.property.predicate.toString()}` : field.property.predicate.toString();
+const atField = (field, ...path) => (issue) => new SchemaIssue.Pointer([field.name, ...path], issue);
+const missing = (field) => atField(field)(new SchemaIssue.MissingKey({
+	messageMissingKey: `Missing value for ${describePredicate(field)}`,
+	predicate: field.property.predicate.value
+}));
+const tooMany = (field, values) => atField(field)(new SchemaIssue.InvalidValue({
+	message: `Expected ${field.optional ? "at most" : "exactly"} one value for ${describePredicate(field)}, got ${values.length}`,
+	predicate: field.property.predicate.value
+}, values));
+const isSubjectTerm = (term) => isSubject(term);
+const encodedValue = (context, item, term, visits) => Option.match(nestedStruct(item), {
+	onNone: () => Effect.succeed(term),
+	onSome: () => isSubjectTerm(term) ? gather(context, item, term, visits) : Effect.fail(new SchemaIssue.InvalidValue({ message: `Expected an IRI or blank node, got ${term.toString()}` }, term))
+});
+const encodedValues = (context, field, terms, visits) => Effect.forEach(terms, (term, index) => Effect.mapError(encodedValue(context, field.item, term, visits), atField(field, index)), { concurrency: 1 });
+const listItems = (context, field, head) => Effect.mapError(Effect.fromOption(list$1(context.dataset, head, context.options.graph)), () => atField(field)(new SchemaIssue.InvalidValue({
+	message: `Expected an RDF list for ${describePredicate(field)}, got ${head.toString()}`,
+	predicate: field.property.predicate.value
+}, head)));
+const encodedField = (context, subject, field, visits) => {
+	const values = valuesOf(context, subject, field);
+	if (field.cardinality === "many") return Arr.isReadonlyArrayEmpty(values) && field.optional ? Effect.succeedNone : Effect.asSome(encodedValues(context, field, values, visits));
+	return Arr.match(values, {
+		onEmpty: () => field.optional ? Effect.succeedNone : Effect.fail(missing(field)),
+		onNonEmpty: ([first, ...rest]) => {
+			if (Arr.isArrayNonEmpty(rest)) return Effect.fail(tooMany(field, values));
+			return field.cardinality === "list" ? Effect.asSome(Effect.flatMap(listItems(context, field, first), (items) => encodedValues(context, field, items, visits))) : Effect.asSome(Effect.mapError(encodedValue(context, field.item, first, visits), atField(field)));
+		}
+	});
+};
+const hasType = (context, subject, type) => Arr.isReadonlyArrayNonEmpty(match(context.dataset, {
+	subject,
+	predicate: rdf.type,
+	object: type,
+	graph: context.options.graph
+})) ? Effect.void : Effect.fail(new SchemaIssue.InvalidValue({
+	message: `Expected ${subject.toString()} to have rdf:type ${type.toString()}`,
+	predicate: rdf.type.value
+}, subject));
+const gather = (context, ast, subject, visits) => Effect.gen(function* () {
+	const struct = yield* expectStruct(ast);
+	if (Arr.some(visits, ([seen, at]) => seen === struct && Equal.equals(at, subject))) return yield* Effect.fail(new SchemaIssue.InvalidValue({ message: `Cycle: ${subject.toString()} is already being decoded as this resource` }, subject));
+	yield* Option.match(describedType(struct), {
+		onNone: () => Effect.void,
+		onSome: (type) => hasType(context, subject, type)
+	});
+	const id = describedId(struct);
+	const inner = [...visits, [struct, subject]];
+	const entries = yield* Effect.forEach(struct.propertySignatures, (signature) => Option.match(keyOf(signature), {
+		onNone: () => Effect.succeedNone,
+		onSome: (name) => Option.contains(id, name) ? Effect.succeedSome([name, subject]) : Option.match(fieldNamed(name, signature), {
+			onNone: () => Effect.succeedNone,
+			onSome: (field) => Effect.map(encodedField(context, subject, field, inner), Option.map((value) => [name, value]))
+		})
+	}), { concurrency: 1 });
+	return Record.fromEntries(Arr.getSomes(entries));
+});
+const contextOf = (dataset, options) => ({
+	dataset,
+	options
+});
+const decodeIssue = (schema, dataset, subject, options, parseOptions) => Effect.flatMap(gather(contextOf(dataset, options), schema.ast, subject, []), (record) => SchemaParser.decodeEffect(schema)(record, parseOptions ?? options.parseOptions));
+const toSchemaError = (issue) => new Schema.SchemaError(issue);
+/**
+* Decodes the resource `subject` of `dataset` with a struct of `property`
+* fields: reads each field's values, checks their number against the field's
+* cardinality, decodes nested resources recursively and runs the struct's
+* decoder over the result.
+*
+* @since 0.1.0
+* @category decoding
+*/
+const decode = (schema) => (dataset, subject, options) => Effect.mapError(decodeIssue(schema, dataset, subject, options ?? {}), toSchemaError);
+/**
+* Decodes every resource whose `rdf:type` is the struct's described `type`
+* (in `Term.Order` of the subjects). Fails on the first resource that does
+* not decode, with the subject at the head of the issue's path; fails when
+* the struct has no described `type`.
+*
+* @since 0.1.0
+* @category decoding
+*/
+const decodeAll = (schema) => (dataset, options) => Option.match(describedType(schema.ast), {
+	onNone: () => Effect.fail(toSchemaError(new SchemaIssue.InvalidValue({ message: "Resource.decodeAll needs a struct described with a type" }))),
+	onSome: (type) => Effect.forEach(Arr.sort(subjectsOf(dataset, rdf.type, type, options?.graph), Order), (subject) => Effect.mapBoth(decodeIssue(schema, dataset, subject, options ?? {}), {
+		onFailure: (issue) => toSchemaError(new SchemaIssue.Pointer([subject.key], issue)),
+		onSuccess: (value) => ({
+			subject,
+			value
+		})
+	}), { concurrency: 1 })
+});
+const isEncodedRecord = (u) => Predicate.isObject(u) && !isTerm(u);
+const read = (record, key) => Option.filter(Record.get(record, key), Predicate.isNotUndefined);
+const unexpected = (expected) => new SchemaIssue.InvalidValue({ message: `Expected the codec to encode to ${expected}` });
+const statement = (field, subject, value, graph) => {
+	const predicate = field.property.predicate;
+	if (field.property.inverse !== true) return Effect.succeed(new Quad(subject, predicate, value, graph));
+	return isSubjectTerm(value) ? Effect.succeed(new Quad(value, predicate, subject, graph)) : Effect.fail(atField(field)(new SchemaIssue.InvalidValue({
+		message: `Expected an IRI or blank node for ${describePredicate(field)}, got ${value.toString()}`,
+		predicate: predicate.value
+	}, value)));
+};
+const collection = (items, graph) => {
+	const nodes = Arr.map(items, () => blankNode());
+	const rests = [...Arr.drop(nodes, 1), rdf.nil];
+	const quads = Arr.flatMap(Arr.zip(nodes, Arr.zip(items, rests)), ([node, [item, rest]]) => [new Quad(node, rdf.first, item, graph), new Quad(node, rdf.rest, rest, graph)]);
+	return [Option.getOrElse(Arr.head(nodes), () => rdf.nil), quads];
+};
+const emitField = (field, subject, record, graph) => Effect.gen(function* () {
+	const items = Option.match(read(record, field.name), {
+		onNone: () => [],
+		onSome: (v) => field.cardinality !== "one" && Arr.isArray(v) ? v : [v]
+	});
+	const nested = nestedStruct(field.item);
+	const emitted = yield* Effect.forEach(items, (item, index) => {
+		const at = field.cardinality === "one" ? atField(field) : atField(field, index);
+		return Option.match(nested, {
+			onNone: () => isObject(item) ? Effect.succeed([item, []]) : Effect.fail(at(unexpected("an RDF term"))),
+			onSome: (struct) => isEncodedRecord(item) ? Effect.mapBoth(emit(struct, Option.none(), item, graph), {
+				onFailure: at,
+				onSuccess: (out) => [out.subject, out.quads]
+			}) : Effect.fail(at(unexpected("a record")))
+		});
+	}, { concurrency: 1 });
+	const inner = Arr.flatMap(emitted, ([, quads]) => quads);
+	const terms = Arr.map(emitted, ([term]) => term);
+	if (field.cardinality === "list" && Option.isSome(read(record, field.name))) {
+		const [head, links] = collection(terms, graph);
+		return [
+			yield* statement(field, subject, head, graph),
+			...links,
+			...inner
+		];
+	}
+	return [...yield* Effect.forEach(terms, (term) => statement(field, subject, term, graph), { concurrency: 1 }), ...inner];
+});
+const emit = (struct, given, record, graph) => Effect.gen(function* () {
+	const id = describedId(struct);
+	const subject = Option.getOrElse(Option.orElse(given, () => Option.filter(Option.flatMap(id, (key) => read(record, key)), (term) => isSubject(term))), () => blankNode());
+	const typed = Arr.map(Arr.fromOption(describedType(struct)), (type) => new Quad(subject, rdf.type, type, graph));
+	const fields = Arr.filter(Arr.getSomes(Arr.map(struct.propertySignatures, fieldOf)), (field) => !Option.contains(id, field.name));
+	const quads = yield* Effect.forEach(fields, (field) => emitField(field, subject, record, graph), { concurrency: 1 });
+	return {
+		subject,
+		quads: [...typed, ...Arr.flatten(quads)]
+	};
+});
+const encodeIssue = (schema, subject, value, options, parseOptions) => Effect.gen(function* () {
+	const struct = yield* expectStruct(schema.ast);
+	const record = yield* SchemaParser.encodeEffect(schema)(value, parseOptions ?? options.parseOptions);
+	return isEncodedRecord(record) ? yield* emit(struct, subject, record, options.graph ?? defaultGraph) : yield* Effect.fail(unexpected("a record"));
+});
+/**
+* Encodes `value` as the resource `subject`: the struct's encoder turns each
+* field into terms, written as `subject predicate term` quads (or
+* `term predicate subject` for an `inverse` field), with an `rdf:type` quad
+* for a described type, RDF collections for `list` fields and the quads of
+* nested resources.
+*
+* @since 0.1.0
+* @category encoding
+*/
+const encode = (schema) => (subject, value, options) => Effect.mapBoth(encodeIssue(schema, Option.some(subject), value, options ?? {}), {
+	onFailure: toSchemaError,
+	onSuccess: (out) => out.quads
+});
+/**
+* A subject term: an IRI, blank node or triple term.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const SubjectSchema = Schema.Union([
+	NamedNodeSchema,
+	BlankNodeSchema,
+	TripleSchema
+]);
+/**
+* The encoded side of `schema`: a dataset and the resource in it.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const InputSchema = Schema.Struct({
+	dataset: DatasetSchema,
+	subject: SubjectSchema
+});
+/**
+* The `Schema` form of `decode` / `encode`: decodes `{ dataset, subject }`
+* to the struct's type, and encodes a value to the dataset of its quads with
+* the resource as `subject` (its `describe`d id, or a fresh blank node). It
+* composes with `Schema.decodeTo`, `Schema.decodeUnknownEffect` and the rest
+* of the `Schema` API.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = (self, options) => InputSchema.pipe(Schema.decodeTo(Schema.toType(self), SchemaTransformation.transformEffect({
+	decode: (input, parseOptions) => decodeIssue(self, input.dataset, input.subject, options ?? {}, parseOptions),
+	encode: (value, parseOptions) => Effect.map(encodeIssue(self, Option.none(), value, options ?? {}, parseOptions), (out) => ({
+		dataset: fromIterable(out.quads),
+		subject: out.subject
+	}))
+})));
+export { Resource_exports as a, decodeAll as c, list as d, property as f, PropertyKey as i, describe as l, InputSchema as n, SubjectSchema as o, schema as p, ListKey as r, decode as s, DescriptionKey as t, encode as u };
+
+//# sourceMappingURL=Resource-sIEeNh15.mjs.map