Immutability.

export function saveTitle(document: Document, title: string): Document {
	return updateTitle(document, title);
}

func SaveTitle(document Document, title string) Document {
	return UpdateTitle(document, title)
}

export type Document = {
	title: string;
	body: string;
	metadata: { tags: string[] };
};

export type ReadonlyDocument = Readonly<{
	title: string;
	body: string;
	metadata: Readonly<{ tags: readonly string[] }>;
}>;

export type Protection = 'readonly' | 'freeze' | 'copy' | 'structural';

export type MutationResult = {
	status: 'mutated' | 'rejected';
	originalChanged: boolean;
	message: string;
};

export function createDocument(): Document {
	return {
		title: 'Release notes',
		body: 'A small, useful update.',
		metadata: { tags: ['product'] }
	};
}

export function asReadOnly(document: Document): ReadonlyDocument {
	return document;
}

export function freezeDocument(document: Document): ReadonlyDocument {
	return deepFreeze(document) as ReadonlyDocument;
}

export function copyDocument(document: Document): Document {
	return {
		title: document.title,
		body: document.body,
		metadata: { tags: [...document.metadata.tags] }
	};
}

export function updateTitle(document: Document, title: string): Document {
	return { ...document, title };
}

export function updateTags(document: Document, tags: string[]): Document {
	return { ...document, metadata: { ...document.metadata, tags: [...tags] } };
}

/** A form edits its own copy; the published document never sees the draft. */
export function draftEdit(document: Document): { published: Document; draft: Document } {
	const draft = copyDocument(document);
	draft.title = 'Edited draft';
	return { published: document, draft };
}

/** A structural update replaces the changed branch and shares the unchanged one. */
export function sharedAfterTitleUpdate(document: Document, title: string) {
	const next = updateTitle(document, title);
	return { next, metadataShared: next.metadata === document.metadata };
}

// The lab's probes: they deliberately bypass readonly at run time to show what each policy
// actually stops. They are a harness for the browser lab, not a pattern to copy.
function deepFreeze<T>(value: T): T {
	if (typeof value !== 'object' || value === null || Object.isFrozen(value)) return value;
	for (const child of Object.values(value as Record<string, unknown>)) deepFreeze(child);
	return Object.freeze(value);
}

export function tryDirectMutation(document: Document, protection: Protection): MutationResult {
	const exposed =
		protection === 'readonly'
			? asReadOnly(document)
			: protection === 'freeze'
				? freezeDocument(document)
				: protection === 'copy'
					? copyDocument(document)
					: document;

	try {
		(exposed as Document).metadata.tags.push('plugin-edit');
		return {
			status: 'mutated',
			originalChanged: document.metadata.tags.includes('plugin-edit'),
			message:
				protection === 'copy'
					? 'The plugin changed its private copy; the published document stayed unchanged.'
					: protection === 'structural'
						? 'Structural sharing is an update strategy, not a runtime shield for a rogue writer.'
						: 'Readonly is a TypeScript promise; JavaScript can still mutate the shared object at runtime.'
		};
	} catch {
		return {
			status: 'rejected',
			originalChanged: false,
			message:
				'The frozen value rejected the write at runtime. The caller must create a new value to edit.'
		};
	}
}

export function editDraft(document: Document, protection: Protection): MutationResult {
	if (protection === 'copy') {
		const draft = copyDocument(document);
		draft.title = 'Edited draft';
		return {
			status: 'mutated',
			originalChanged: document.title === 'Edited draft',
			message:
				'The form owns an independent draft and can edit it without changing the published value.'
		};
	}
	if (protection === 'structural') {
		const next = updateTitle(document, 'Edited draft');
		return {
			status: 'mutated',
			originalChanged: document.title === 'Edited draft',
			message: `The edit returns a new root (${next !== document ? 'new identity' : 'same identity'}); unchanged metadata can remain shared.`
		};
	}
	const exposed = protection === 'readonly' ? asReadOnly(document) : freezeDocument(document);
	try {
		(exposed as Document).title = 'Edited draft';
		return {
			status: 'mutated',
			originalChanged: document.title === 'Edited draft',
			message:
				'The draft edit reached the published object; the boundary did not provide independent ownership.'
		};
	} catch {
		return {
			status: 'rejected',
			originalChanged: false,
			message:
				'The frozen value rejected the edit. The editor needs a replacement draft or update function.'
		};
	}
}

export function saveTitle(document: Document, title: string): Document {
	return updateTitle(document, title);
}

export function example() {
	const published = createDocument();
	const next = saveTitle(published, 'Launch notes');
	return { published, next, metadataShared: published.metadata === next.metadata };
}

console.log(example());

package main

import "fmt"

type Document struct {
	Title    string
	Body     string
	Metadata Metadata
}

type Metadata struct {
	Tags []string
}

func NewDocument() Document {
	return Document{Title: "Release notes", Body: "A small, useful update.", Metadata: Metadata{Tags: []string{"product"}}}
}

func CopyDocument(document Document) Document {
	tags := append([]string(nil), document.Metadata.Tags...)
	document.Metadata.Tags = tags
	return document
}

func UpdateTitle(document Document, title string) Document {
	document.Title = title
	return document
}

func UpdateTags(document Document, tags []string) Document {
	document.Metadata.Tags = append([]string(nil), tags...)
	return document
}


// TryDraftEdit edits a copy; the published document never sees the draft.
func TryDraftEdit(document Document) (Document, Document) {
	draft := CopyDocument(document)
	draft.Title = "Edited draft"
	return document, draft
}

// SharedAfterTitleUpdate reports whether the updated value still shares the
// tags backing array. With no tags there is no backing array to share.
func SharedAfterTitleUpdate(document Document, title string) (Document, bool) {
	next := UpdateTitle(document, title)
	shared := len(document.Metadata.Tags) > 0 && &next.Metadata.Tags[0] == &document.Metadata.Tags[0]
	return next, shared
}


func SaveTitle(document Document, title string) Document {
	return UpdateTitle(document, title)
}


func main() {
	published := NewDocument()
	next := SaveTitle(published, "Launch notes")
	fmt.Printf("published=%q next=%q tags=%v\n", published.Title, next.Title, next.Metadata.Tags)
}