refactor: rewrite untracked, update alien-signals

benches/propagate.luau

@@ -4,6 +4,7 @@ local bench = require("./bench")
 local atom = Charm.atom
 local computed = Charm.computed
 local effect = Charm.effect
+local listen = Charm.listen
 
 for _, w in { 10, 100 } do
 	for _, h in { 10, 100 } do
@@ -25,3 +26,22 @@ for _, w in { 10, 100 } do
 		end)
 	end
 end
+
+for _, w in { 10, 100 } do
+	for _, h in { 10, 100 } do
+		bench.run(`propagate (listen) {w}*{h}`, function()
+			local src = atom(1)
+			for _ = 1, w do
+				local last = src
+				for _ = 1, h do
+					local prev = last
+					last = computed(function()
+						return prev() + 1
+					end)
+				end
+				listen(last, function() end)
+			end
+			src(src() + 1)
+		end)
+	end
+end

package.json

@@ -7,7 +7,7 @@
 		"publish:npm": "pnpm publish -r --access public",
 		"publish:wally": "pnpm -r --workspace-concurrency 1 publish:wally"
 	},
-	"packageManager": "pnpm@10.12.4",
+	"packageManager": "pnpm@10.17.1",
 	"devDependencies": {
 		"@rbxts-js/react": "17.1.20-ts.1",
 		"@rbxts-js/react-roblox": "17.1.20-ts.1",

packages/charm-sync/src/types.luau

@@ -4,13 +4,15 @@ type Atom<T> = Charm.Atom<T>
 
 --- A payload that can be sent from the server to the client to synchronize
 --- state between the two.
-export type SyncPayload = {
+export type SyncPayload =
-	type: "init",
+	| {
-	data: { [string | number]: any },
+		type: "init",
-} | {
+		data: { [string | number]: any },
-	type: "patch",
+	}
-	data: { [string | number]: any },
+	| {
-}
+		type: "patch",
+		data: { [string | number]: any },
+	}
 
 export type AtomMap = {
 	[string | number]: Atom<any>,

packages/charm/src/__tests__/core/effect.spec.luau

@@ -356,4 +356,25 @@ test("should run cleanups outside any evaluation context", function()
 	assert(calls == 0, "should not run after b update")
 end)
 
+test("should allow self cleanup", function()
+	local calls = 0
+	local cleanups = 0
+	local a = atom(0)
+
+	effect(function(stopEffect)
+		onCleanup(function()
+			cleanups += 1
+		end)
+		stopEffect()
+		a()
+		calls += 1
+	end)
+
+	assert(calls == 1, "should call effect once")
+	assert(cleanups == 1, "should call cleanup once")
+	a(1)
+	assert(calls == 1, "should not call effect after a update")
+	assert(cleanups == 1, "should not call cleanup after a update")
+end)
+
 return {}

packages/charm/src/__tests__/listen.spec.luau

@@ -4,6 +4,7 @@ local suite = require("../../../../test/suite")
 local atom = Charm.atom
 local listen = Charm.listen
 local effect = Charm.effect
+local onCleanup = Charm.onCleanup
 local test = suite.test
 
 test("should listen to selector", function()
@@ -115,4 +116,24 @@ test("should skip redundant updates", function()
 	assert(table.concat(order) == "evenoddeven", `bad order: {table.concat(order)}`)
 end)
 
+test("should allow self cleanup", function()
+	local calls = 0
+	local cleanups = 0
+	local a = atom(0)
+
+	listen(a, function(_, _, stopEffect)
+		onCleanup(function()
+			cleanups += 1
+		end)
+		stopEffect()
+		calls += 1
+	end)
+
+	assert(calls == 1, "should call effect once")
+	assert(cleanups == 1, "should call cleanup once")
+	a(1)
+	assert(calls == 1, "should not call effect after a update")
+	assert(cleanups == 1, "should not call cleanup after a update")
+end)
+
 return {}

packages/charm/src/__tests__/observe.spec.luau

@@ -61,4 +61,36 @@ test("should dispose scopes", function()
 	assert(table.concat(runs) == "", `should not rerun: {table.concat(runs)}`)
 end)
 
+test("should queue addition", function()
+	local items = atom({ 1 })
+	local edits = {}
+
+	observe(items, function(item)
+		items({ 1, 2 })
+		items({ 1, 2, 3, 4 })
+		table.insert(edits, `+{item}`)
+		return function()
+			table.insert(edits, `-{item}`)
+		end
+	end)
+
+	assert(table.concat(edits) == "+1+2+3+4", `bad edits: {table.concat(edits)}`)
+end)
+
+test("should queue removal", function()
+	local items = atom({ 1, 2, 3, 4 })
+	local edits = {}
+
+	observe(items, function(item)
+		items({ 1, 2, 3 })
+		items({ 1 })
+		table.insert(edits, `+{item}`)
+		return function()
+			table.insert(edits, `-{item}`)
+		end
+	end)
+
+	assert(table.concat(edits) == "+1+2+3+4-2-3-4", `bad edits: {table.concat(edits)}`)
+end)
+
 return {}

packages/charm/src/__tests__/untracked.spec.luau

@@ -105,4 +105,26 @@ test("should block tracking inside computed atoms", function()
 	assert(c() == 3, "c should be 3")
 end)
 
+test("should track outside untracked", function()
+	local a = atom(1)
+	local b = atom(2)
+	local c = atom(3)
+	local spyCalls = 0
+
+	effect(function()
+		a()
+		untracked(c)
+		b()
+		spyCalls += 1
+	end)
+
+	assert(spyCalls == 1, "should be called once")
+	a(10)
+	assert(spyCalls == 2, "should be called twice")
+	b(20)
+	assert(spyCalls == 3, "should be called three times")
+	c(30)
+	assert(spyCalls == 3, "should not run on c change")
+end)
+
 return {}

packages/charm/src/batched.luau

@@ -1,7 +1,10 @@
 local core = require("./core")
+local flags = require("./flags")
+local utils = require("./utils")
 
 local startBatch = core.startBatch
 local endBatch = core.endBatch
+local noYield = utils.noYield
 
 local function handleBatched(ok: boolean, ...)
 	endBatch()
@@ -14,7 +17,7 @@ end
 
 local function batched<Args..., Results...>(callback: (Args...) -> Results..., ...: Args...): Results...
 	startBatch()
-	return handleBatched(pcall(callback, ...))
+	return handleBatched((if flags.strict then noYield else pcall)(callback, ...))
 end
 
 return batched

packages/charm/src/core.luau

@@ -21,14 +21,16 @@ local WATCHING = 0b0000010
 local DIRTY = 0b0010000
 local PENDING = 0b0100000
 local QUEUED = 0b1000000
+local UNTRACKED = 0b10000000
 
 type EffectScope = ReactiveNode & {
 	cleanups: { () -> () },
 }
 
 type Effect = ReactiveNode & {
-	fn: () -> ...(() -> ())?,
+	fn: (dispose: () -> ()) -> ...(() -> ())?,
 	cleanups: { () -> () },
+	cleanup: () -> (),
 }
 
 type Computed<T = any> = ReactiveNode & {
@@ -59,7 +61,6 @@ local notifyIndex = 0
 
 local activeScope: Effect | EffectScope?
 local activeSub: ReactiveNode?
-local activeSubWatching = true
 
 local function getCurrentSub(): ReactiveNode?
 	return activeSub
@@ -81,16 +82,10 @@ local function setCurrentScope(scope: Effect | EffectScope?)
 	return prevScope
 end
 
-local function setCurrentWatching(watching: boolean): boolean
-	local prevSubWatching = activeSubWatching
-	activeSubWatching = watching
-	return prevSubWatching
-end
-
 local function runCleanups(effect: EffectScope)
 	for _, cleanup in effect.cleanups do
 		local prev = setCurrentSub(nil)
-		local success, result: any = (config.strict and noYield or pcall)(cleanup)
+		local success, result: any = (if config.strict then noYield else pcall)(cleanup)
 		setCurrentSub(prev)
 		if not success then
 			error(result)
@@ -113,12 +108,10 @@ local function run(effect: Effect, flags: ReactiveFlags): ()
 	if bit32.btest(flags, DIRTY) or (bit32.btest(flags, PENDING) and checkDirty(effect.deps :: Link, effect)) then
 		runCleanups(effect)
 		local prev = setCurrentSub(effect)
-		local prevTracking = setCurrentWatching(true)
 		startTracking(effect)
-		local success, result: (() -> ())? = (config.strict and noYield or pcall)(effect.fn)
+		local success, result: (() -> ())? = (if config.strict then noYield else pcall)(effect.fn, effect.cleanup)
 		setCurrentSub(prev)
 		endTracking(effect)
-		setCurrentWatching(prevTracking)
 		if not success then
 			error(result)
 		elseif result then
@@ -170,13 +163,11 @@ end
 
 local function updateComputed(computed: Computed): boolean
 	local prevSub = setCurrentSub(computed)
-	local prevWatching = setCurrentWatching(true)
 	startTracking(computed)
 	local oldValue = computed.value
-	local success, result = (config.strict and noYield or pcall)(computed.getter, oldValue)
+	local success, result = (if config.strict then noYield else pcall)(computed.getter, oldValue)
 	setCurrentSub(prevSub)
 	endTracking(computed)
-	setCurrentWatching(prevWatching)
 	if not success then
 		error(result)
 	end
@@ -209,7 +200,7 @@ local function readAtom<T>(atom: Atom<T>): T
 			end
 		end
 	end
-	if activeSub and activeSubWatching then
+	if activeSub and not bit32.btest(activeSub.flags, UNTRACKED) then
 		link(atom, activeSub)
 	end
 	return value
@@ -244,7 +235,7 @@ local function atomGetterSetter<T>(atom: Atom<T>): (...((T) -> T) | T) -> T
 		local newValue = ...
 		if type(newValue) == "function" then
 			local prev = setCurrentSub(nil)
-			local success, result = (config.strict and noYield or pcall)(newValue, oldValue)
+			local success, result = (if config.strict then noYield else pcall)(newValue, oldValue)
 			setCurrentSub(prev)
 			if not success then
 				error(result)
@@ -270,7 +261,7 @@ local function computedGetter<T>(computed: Computed<T>): () -> T
 		elseif bit32.btest(flags, PENDING) then
 			computed.flags = bit32.band(flags, bit32.bnot(PENDING))
 		end
-		if activeSub and activeSubWatching then
+		if activeSub and not bit32.btest(activeSub.flags, UNTRACKED) then
 			link(computed, activeSub)
 		elseif activeScope then
 			link(computed, activeScope)
@@ -350,28 +341,28 @@ local function computed<T>(getter: (previousValue: T?) -> T, equals: ((T, T) ->
 	})
 end
 
-local function effect(fn: () -> ...(() -> ())?): () -> ()
+local function effect(fn: (dispose: () -> ()) -> ...(() -> ())?): () -> ()
 	local self: Effect = {
 		fn = fn,
 		flags = WATCHING,
 		cleanups = {},
+		cleanup = nil :: any,
 	}
+	self.cleanup = effectStop(self)
 	if activeSub then
 		link(self, activeSub)
 	elseif activeScope then
 		link(self, activeScope)
 	end
 	local prev = setCurrentSub(self)
-	local prevWatching = setCurrentWatching(true)
+	local success, result: (() -> ())? = (if config.strict then noYield else pcall)(fn, self.cleanup)
-	local success, result: (() -> ())? = (config.strict and noYield or pcall)(fn)
 	setCurrentSub(prev)
-	setCurrentWatching(prevWatching)
 	if not success then
 		error(result)
 	elseif result then
 		table.insert(self.cleanups, result)
 	end
-	return effectStop(self)
+	return self.cleanup
 end
 
 local function effectScope(fn: () -> ...(() -> ())?, detached: boolean?): () -> ()
@@ -384,7 +375,7 @@ local function effectScope(fn: () -> ...(() -> ())?, detached: boolean?): () ->
 	end
 	local prevSub = setCurrentSub(nil)
 	local prevScope = setCurrentScope(self)
-	local success, result: (() -> ())? = (config.strict and noYield or pcall)(fn)
+	local success, result: (() -> ())? = (if config.strict then noYield else pcall)(fn)
 	setCurrentScope(prevScope)
 	setCurrentSub(prevSub)
 	if not success then
@@ -416,7 +407,6 @@ return {
 	setCurrentSub = setCurrentSub,
 	getCurrentScope = getCurrentScope,
 	setCurrentScope = setCurrentScope,
-	setCurrentWatching = setCurrentWatching,
 	onCleanup = onCleanup,
 	getBatchDepth = getBatchDepth,
 	startBatch = startBatch,

packages/charm/src/init.luau

@@ -1,3 +1,5 @@
+--!nolint DeprecatedApi
+
 local batched = require("@self/batched")
 local core = require("@self/core")
 local flags = require("@self/flags")

packages/charm/src/observe.luau

@@ -3,6 +3,8 @@ local core = require("./core")
 local effect = core.effect
 local effectScope = core.effectScope
 local onCleanup = core.onCleanup
+local startBatch = core.startBatch
+local endBatch = core.endBatch
 
 local function observe<K, V>(selector: () -> { [K]: V }, observer: (item: V, key: K) -> ...(() -> ())?): () -> ()
 	local scopes: { [K]: () -> () } = {}
@@ -18,7 +20,7 @@ local function observe<K, V>(selector: () -> { [K]: V }, observer: (item: V, key
 		end
 
 		for key, value in currentItems do
-			if previousItems[key] == nil then
+			if previousItems[key] == nil and scopes[key] == nil then
 				scopes[key] = effectScope(function()
 					return observer(value, key)
 				end, true)
@@ -37,7 +39,9 @@ local function observe<K, V>(selector: () -> { [K]: V }, observer: (item: V, key
 		local previousItems = currentItems
 		currentItems = selector()
 		if currentItems ~= previousItems then
+			startBatch()
 			updateScopes(currentItems, previousItems)
+			endBatch()
 		end
 	end)
 

packages/charm/src/system.luau

@@ -11,6 +11,7 @@ export type ReactiveNode = {
 }
 
 export type Link = {
+	version: number,
 	dep: ReactiveNode,
 	sub: ReactiveNode,
 	prevSub: Link?,
@@ -26,13 +27,14 @@ type Stack<T> = {
 
 export type ReactiveFlags = number
 
-local NONE = 0b0000000
+local NONE = 0b00000000
-local MUTABLE = 0b0000001
+local MUTABLE = 0b00000001
-local WATCHING = 0b0000010
+local WATCHING = 0b00000010
-local RECURSED_CHECK = 0b0000100
+local RECURSED_CHECK = 0b00000100
-local RECURSED = 0b0001000
+local RECURSED = 0b00001000
-local DIRTY = 0b0010000
+local DIRTY = 0b00010000
-local PENDING = 0b0100000
+local PENDING = 0b00100000
+local UNTRACKED = 0b10000000
 
 local ReactiveFlags = {
 	None = NONE,
@@ -42,6 +44,7 @@ local ReactiveFlags = {
 	Recursed = RECURSED,
 	Dirty = DIRTY,
 	Pending = PENDING,
+	Untracked = UNTRACKED,
 }
 
 local function createReactiveSystem(props: {
@@ -52,20 +55,15 @@ local function createReactiveSystem(props: {
 	local update = props.update
 	local notify = props.notify
 	local unwatched = props.unwatched
+	local currentVersion = 0
 
 	local function isValidLink(checkLink: Link, sub: ReactiveNode): boolean
-		local depsTail = sub.depsTail
+		local link = sub.depsTail
-		if depsTail then
+		while link do
-			local link = sub.deps :: Link
+			if link == checkLink then
-			repeat
+				return true
-				if link == checkLink then
+			end
-					return true
+			link = link.prevDep
-				end
-				if link == depsTail then
-					break
-				end
-				link = link.nextDep :: Link
-			until not link
 		end
 		return false
 	end
@@ -75,20 +73,18 @@ local function createReactiveSystem(props: {
 		if prevDep and prevDep.dep == dep then
 			return
 		end
-		local nextDep: Link?
+		local nextDep = if prevDep then prevDep.nextDep else sub.deps
-		local recursedCheck = bit32.btest(sub.flags, RECURSED_CHECK)
+		if nextDep and nextDep.dep == dep then
-		if recursedCheck then
+			nextDep.version = currentVersion
-			nextDep = if prevDep then prevDep.nextDep else sub.deps
+			sub.depsTail = nextDep
-			if nextDep and nextDep.dep == dep then
+			return
-				sub.depsTail = nextDep
-				return
-			end
 		end
 		local prevSub = dep.subsTail
-		if prevSub and prevSub.sub == sub and (not recursedCheck or isValidLink(prevSub, sub)) then
+		if prevSub and prevSub.version == currentVersion and prevSub.sub == sub then
 			return
 		end
 		local newLink: Link = {
+			version = currentVersion,
 			dep = dep,
 			sub = sub,
 			prevDep = prevDep,
@@ -154,35 +150,34 @@ local function createReactiveSystem(props: {
 
 			local flags = sub.flags
 
-			if bit32.btest(flags, bit32.bor(MUTABLE, WATCHING)) then
+			if not bit32.btest(flags, bit32.bor(RECURSED_CHECK, RECURSED, DIRTY, PENDING)) then
-				if not bit32.btest(flags, bit32.bor(RECURSED_CHECK, RECURSED, DIRTY, PENDING)) then
+				sub.flags = bit32.bor(flags, PENDING)
-					sub.flags = bit32.bor(flags, PENDING)
+			elseif not bit32.btest(flags, bit32.bor(RECURSED_CHECK, RECURSED)) then
-				elseif not bit32.btest(flags, bit32.bor(RECURSED_CHECK, RECURSED)) then
+				flags = NONE
-					flags = NONE
+			elseif not bit32.btest(flags, RECURSED_CHECK) then
-				elseif not bit32.btest(flags, RECURSED_CHECK) then
+				sub.flags = bit32.bor(bit32.band(flags, bit32.bnot(RECURSED)), PENDING)
-					sub.flags = bit32.bor(bit32.band(flags, bit32.bnot(RECURSED)), PENDING)
+			elseif not bit32.btest(flags, bit32.bor(DIRTY, PENDING)) and isValidLink(link, sub) then
-				elseif not bit32.btest(flags, bit32.bor(DIRTY, PENDING)) and isValidLink(link, sub) then
+				sub.flags = bit32.bor(flags, bit32.bor(RECURSED, PENDING))
-					sub.flags = bit32.bor(flags, bit32.bor(RECURSED, PENDING))
+				flags = bit32.band(flags, MUTABLE)
-					flags = bit32.band(flags, MUTABLE)
+			else
-				else
+				-- selene: allow(if_same_then_else)
-					-- selene: allow(if_same_then_else)
+				flags = NONE
-					flags = NONE
+			end
-				end
 
-				if bit32.btest(flags, WATCHING) then
+			if bit32.btest(flags, WATCHING) then
-					notify(sub)
+				notify(sub)
-				end
+			end
 
-				if bit32.btest(flags, MUTABLE) then
+			if bit32.btest(flags, MUTABLE) then
-					local subSubs = sub.subs
+				local subSubs = sub.subs
-					if subSubs then
+				if subSubs then
-						link = subSubs
+					link = subSubs
-						if subSubs.nextSub then
+					local nextSub = link.nextSub
-							stack = { value = next, prev = stack }
+					if nextSub then
-							next = link.nextSub
+						stack = { value = next, prev = stack }
-						end
+						next = nextSub
-						continue
 					end
+					continue
 				end
 			end
 
@@ -214,6 +209,7 @@ local function createReactiveSystem(props: {
 	end
 
 	local function startTracking(sub: ReactiveNode): ()
+		currentVersion += 1
 		sub.depsTail = nil
 		sub.flags = bit32.bor(bit32.band(sub.flags, bit32.bnot(bit32.bor(RECURSED, DIRTY, PENDING))), RECURSED_CHECK)
 	end
@@ -230,10 +226,10 @@ local function createReactiveSystem(props: {
 	local function shallowPropagate(link: Link): ()
 		repeat
 			local sub = link.sub
-			local subFlags = sub.flags
+			local flags = sub.flags
-			if bit32.band(subFlags, bit32.bor(PENDING, DIRTY)) == PENDING then
+			if bit32.band(flags, bit32.bor(PENDING, DIRTY)) == PENDING then
-				sub.flags = bit32.bor(subFlags, DIRTY)
+				sub.flags = bit32.bor(flags, DIRTY)
-				if bit32.btest(subFlags, WATCHING) then
+				if bit32.btest(flags, WATCHING) then
 					notify(sub)
 				end
 			end
@@ -244,16 +240,15 @@ local function createReactiveSystem(props: {
 	local function checkDirty(link: Link, sub: ReactiveNode): boolean
 		local stack: Stack<Link>?
 		local checkDepth = 0
+		local dirty = false
 
 		repeat
 			local dep = link.dep
-			local depFlags = dep.flags
+			local flags = dep.flags
-
-			local dirty = false
 
 			if bit32.btest(sub.flags, DIRTY) then
 				dirty = true
-			elseif bit32.band(depFlags, bit32.bor(MUTABLE, DIRTY)) == bit32.bor(MUTABLE, DIRTY) then
+			elseif bit32.band(flags, bit32.bor(MUTABLE, DIRTY)) == bit32.bor(MUTABLE, DIRTY) then
 				if update(dep) then
 					local subs = dep.subs :: Link
 					if subs.nextSub then
@@ -261,7 +256,7 @@ local function createReactiveSystem(props: {
 					end
 					dirty = true
 				end
-			elseif bit32.band(depFlags, bit32.bor(MUTABLE, PENDING)) == bit32.bor(MUTABLE, PENDING) then
+			elseif bit32.band(flags, bit32.bor(MUTABLE, PENDING)) == bit32.bor(MUTABLE, PENDING) then
 				if link.nextSub or link.prevSub then
 					stack = { value = link, prev = stack }
 				end
@@ -271,9 +266,12 @@ local function createReactiveSystem(props: {
 				continue
 			end
 
-			if not dirty and link.nextDep then
+			if not dirty then
-				link = link.nextDep
+				local nextDep = link.nextDep
-				continue
+				if nextDep then
+					link = nextDep
+					continue
+				end
 			end
 
 			local continueTop = false
@@ -296,16 +294,17 @@ local function createReactiveSystem(props: {
 						sub = link.sub
 						continue
 					end
+					dirty = false
 				else
 					sub.flags = bit32.band(sub.flags, bit32.bnot(PENDING))
 				end
 				sub = link.sub
-				if link.nextDep then
+				local nextDep = link.nextDep
-					link = link.nextDep
+				if nextDep then
+					link = nextDep
 					continueTop = true
 					break
 				end
-				dirty = false
 			end
 
 			if continueTop then

packages/charm/src/untracked.luau

@@ -1,9 +1,12 @@
 local core = require("./core")
 
-local setCurrentWatching = core.setCurrentWatching
+local UNTRACKED = core.ReactiveFlags.Untracked
+local getCurrentSub = core.getCurrentSub
 
-local function handleUntracked(prevWatching: boolean, ok: boolean, ...)
+local function handleUntracked(sub: core.ReactiveNode?, ok: boolean, ...)
-	setCurrentWatching(prevWatching)
+	if sub then
+		sub.flags = bit32.band(sub.flags, bit32.bnot(UNTRACKED))
+	end
 	if ok then
 		return ...
 	else
@@ -12,7 +15,13 @@ local function handleUntracked(prevWatching: boolean, ok: boolean, ...)
 end
 
 local function untracked<Args..., Results...>(callback: (Args...) -> Results..., ...: Args...): Results...
-	return handleUntracked(setCurrentWatching(false), pcall(callback, ...))
+	local sub = getCurrentSub()
+	if not sub or bit32.btest(sub.flags, UNTRACKED) then
+		return callback(...)
+	else
+		sub.flags = bit32.bor(sub.flags, UNTRACKED)
+	end
+	return handleUntracked(sub, pcall(callback, ...))
 end
 
 return untracked

rokit.toml

@@ -6,8 +6,8 @@
 [tools]
 wally = "UpliftGames/wally@0.3.2"
 rojo = "rojo-rbx/rojo@7.5.1"
-stylua = "johnnymorganz/stylua@2.1.0"
+stylua = "johnnymorganz/stylua@2.2.0"
-selene = "Kampfkarren/selene@0.28.0"
+selene = "Kampfkarren/selene@0.29.0"
-luau-lsp = "johnnymorganz/luau-lsp@1.51.0"
+luau-lsp = "johnnymorganz/luau-lsp@1.53.5"
-lune = "lune-org/lune@0.9.4"
+lune = "lune-org/lune@0.10.2"
-lute = "luau-lang/lute@0.1.0-nightly.20250701"
+lute = "luau-lang/lute@0.1.0-nightly.20250923"

selene.toml

@@ -1,5 +1,5 @@
 std = "selene_defs"
-exclude = ["**/node_modules/**"]
+exclude = ["*/node_modules/*"]
 
 [lints]
 global_usage = "allow"